
% The Polish Valence Dictionary (Walenty)
% September 14, 2014
%
% The Polish Valence Dictionary (Walenty) is an adaptation of
% the Syntactic Dictionary of Polish Verbs by Marek Świdziński
% in its electronic version provided by Łukasz Dębowski and
% Elżbieta Hajnicz and further expanded by Witold Kieraś to
% include the most frequent verbs in the 1 million sample of
% NKJP (National Corpus of Polish).
%
% The presented resource results from an automatic conversion
% of the aforementioned dictionary, manually reviewed by Filip
% Skwarski to include correct information about a number of new
% features, including sentential subjects, passivisation, and
% control relations.
%
% The format of the new dictionary has been established by Filip
% Skwarski, Elżbieta Hajnicz, Agnieszka Patejuk, Adam Przepiórkowski,
% Marek Świdziński, and Marcin Woliński.
%
% The dictionary has been edited and compiled using a tool
% created by Bartłomiej Nitoń.
%
% The original Syntactic Dictionary of Polish Verbs derives from:
%
% Marek Świdziński
% Institute of Polish
% Warsaw University
% Warsaw, Poland
%
% © Copyright 1998,2012 by Marek Świdziński
%
% This work is distributed under a CC BY-SA license:
% http://creativecommons.org/licenses/by-sa/2.0/
%
% Parameters:
%     Dictionaries:   clarin1, clarin10, clarin11, clarin12, clarin13, clarin14, clarin15, clarin16, clarin17, clarin2, clarin3, clarin4, clarin5, clarin6, clarin7, clarin8, clarin9, clarin_adjs1, clarin_diff, clarin_nouns1, czas_czasu, czas_emotywne, czas_mentalne, czas_misc1, czas_misc2, czas_misc3, czas_mowienia, czas_operacji, czas_percepcji, czas_percepcji2, czas_przemieszczenia, frek1, frek10, frek2, frek3, frek4, frek5, frek6, frek7, frek8, frek9
%     Frame opinions: pewna, wątpliwa, archaiczna, potoczna, wulgarna
%     Lemma statuses: tymczasowy, sprawdzone
%     Owners:         AgnieszkaN, AnnaG, BarbaraL, FilipS, JakubS, JoannaF, MaciejZ, MagdaB, MarcinO, MartaK, NataliaZ, PaulinaR, PiotrB, SebasZ
%     Realizations:   None
%     Opinions added: False
%     
abdykować: _: : _: subj{np(str)} + {comprepnp(na rzecz)} + {xp(abl)}
abdykować: _: : _: subj{np(str)} + {prepnp(z,gen)} + {comprepnp(na rzecz)}
abonować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
abonować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
absorbować: _: : imperf: subj{cp(int)} + {np(str)}
absorbować: _: : imperf: subj{cp(żeby)} + {np(str)}
absorbować: _: : imperf: subj{cp(że)} + {np(str)}
absorbować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + obj{np(str)}
absorbować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
absorbować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)}
abstrahować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
abstrahować: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
absurdalny: : : : {prepnp(dla,gen)}
absurdalny: : : : {prepnp(w,loc)}
absurdalny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
absurdalny: : pred: : {prepnp(dla,gen)} + {cp(int)}
absurdalny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
absurdalny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
absurdalny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
absurdalny: : pred: : {prepnp(dla,gen)} + {cp(że)}
absurdalny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
adaptować się: _: : _: subj{np(str)} + {prepnp(do,gen)}
adaptować się: _: : _: subj{np(str)} + {xp(locat)}
adaptować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
adaptować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
adaptować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
adekwatny: : : : {comprepnp(w stosunku do)}
adekwatny: : : : {prepncp(do,gen,że)}
adekwatny: : : : {prepncp(do,gen,żeby)}
adekwatny: : : : {prepncp(z,inst,że)}
adekwatny: : : : {prepnp(dla,gen); prepnp(do,gen); prepncp(do,gen,int)}
adekwatny: : : : {prepnp(wobec,gen)}
adekwatny: : : : {prepnp(względem,gen)}
adekwatny: : : : {prepnp(z,inst); prepncp(z,inst,int)}
administracja: : : : {np(gen)}
administracja: : : : {np(inst)} + {possp}
administrować: _: : imperf: subj{np(str)} + obj{np(inst)}
adoptować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)}
adorować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
adresować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
adresować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
afera: : : : {possp} + {comprepnp(na temat)}
afera: : : : {possp} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
afera: : : : {possp} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że)}
afera: : : : {possp} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
agitować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
agitować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
agitować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
agitować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)}
agitować: _: : imperf: subj{np(str)} + {or}
agitować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)} + {prepnp(wśród,gen)}
agitować: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
agitować: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)} + {comprepnp(na rzecz)}
agitować: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)} + {comprepnp(w sprawie)}
agitować: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(że)}
agitować: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(żeby)}
agresja: : : : {possp} + {comprepnp(w stosunku do)}
agresja: : : : {possp} + {prepnp(na,acc)}
agresja: : : : {possp} + {prepnp(przeciw,dat)}
agresja: : : : {possp} + {prepnp(wobec,gen)}
akcentować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(inst)}
akcentować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(inst)}
akcentować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
akcentować: _: : imperf: subj{np(str)} + {or}
akceptować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
akceptować: _: : imperf: subj{np(str)} + obj{cp(int)}
akceptować: _: : imperf: subj{np(str)} + obj{cp(że)}
akceptować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
akceptować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
akcja: : : : {np(gen)} + {possp}
akcja: : : : {possp} + {comprepnp(na rzecz); preplexnp(w,loc,sg,'obrona',atr)}
akcja: : : : {possp} + {comprepnp(w sprawie)}
akcja: : : : {possp} + {cp(że)}
akcja: : : : {possp} + {cp(żeby)}
akcja: : : : {possp} + {prepnp(na,acc)}
akcja: : : : {possp} + {prepnp(przeciw,dat); prepncp(przeciw,dat,żeby)}
aklimatyzować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
aklimatyzować się: _: : imperf: subj{np(str)} + {xp(locat)}
aklimatyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
aklimatyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
akompaniować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
akompaniować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(na,loc)}
akompaniować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(przy,loc)}
akompaniować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(w,loc)}
akredytować się: _: : _: subj{np(str)} + {prepnp(na,acc)}
akredytować się: _: : _: subj{np(str)} + {prepnp(przy,loc)}
akredytować się: _: : _: subj{np(str)} + {xp(locat)}
akredytować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
akredytować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
akredytować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
aktualizować się: _: : imperf: subj{np(str)}
aktualizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
aktywizować się: _: : imperf: subj{np(str)} + {advp(misc)}
aktywizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
aktywizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
aktywować się: _: : _: subj{np(str)} + {np(dat)}
aktywować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
alarmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {comprepnp(w kwestii)}
alarmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {comprepnp(w sprawie)}
alarmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
alarmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
alarmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
alarmować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
album: : : : {possp} + {comprepnp(na temat)}
album: : : : {possp} + {prepnp(na,acc)}
album: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
album: : : : {possp} + {prepnp(z,inst)}
alternatywny: : : : {comprepnp(w stosunku do)}
alternatywny: : : : {prepnp(dla,gen); prepncp(dla,gen,int)}
alternatywny: : : : {prepnp(do,gen); prepncp(do,gen,int)}
alternatywny: : : : {prepnp(wobec,gen); prepncp(wobec,gen,int)}
alternatywny: : : : {prepnp(względem,gen)}
ambicja: : : : {np(gen)} + {possp}
ambicja: : : : {possp} + {comprepnp(co do)}
ambicja: : : : {possp} + {comprepnp(w kwestii)}
ambicja: : : : {possp} + {comprepnp(w sprawie)}
ambicja: : : : {possp} + {comprepnp(w stosunku do)}
ambicja: : : : {possp} + {cp(żeby)}
amortyzować się: _: : imperf: subj{np(str)} + {np(dat)}
amortyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
amputować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
amputować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
amputować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
analizować: _: : imperf: subj{np(str)} + obj{cp(int)}
analizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
analogiczny: : : : {comp(jak)}
analogiczny: : : : {comprepnp(w stosunku do)}
analogiczny: : : : {prepncp(do,gen,że)}
analogiczny: : : : {prepnp(do,gen); prepncp(do,gen,int)}
analogiczny: : : : {prepnp(wobec,gen)}
analogiczny: : : : {prepnp(względem,gen)}
analogiczny: : : : {prepnp(z,inst); prepncp(z,inst,int)}
anektować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
anektować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
anektować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
anektować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
angażować się: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
angażować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
angażować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
angażować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
angażować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
angażować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
animować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
animować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
anonimizować: _: : imperf: subj{np(str)} + obj{np(str)}
antycypować: _: : imperf: subj{np(str)} + {cp(int)}
antycypować: _: : imperf: subj{np(str)} + {cp(że)}
antycypować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
anulować: _: : perf: subj{np(str)} + {ncp(str,że)}
anulować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
apel: : : : {possp} + {prepnp(do,gen)} + {comprepnp(na temat)}
apel: : : : {possp} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
apel: : : : {possp} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
apel: : : : {possp} + {prepnp(do,gen)} + {cp(że)}
apel: : : : {possp} + {prepnp(do,gen)} + {or}
apel: : : : {possp} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(przeciw,dat); cp(żeby); prepncp(o,acc,żeby)}
apelować: _: : imperf: subj{np(str)} + {preplexnp(od,gen,_,'wyrok',atr)}
apelować: _: : imperf: subj{np(str)} + {prepncp(do,gen,żeby)}
apelować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
apelować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
apelować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
apelować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
apelować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
aplikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
aplikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
aplikować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
aplikować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
aplikować: _: : imperf: subj{np(str)} + {xp(locat)}
aportować: _: : imperf: subj{np(str)} + obj{np(str)}
aportować: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
aprobować: _: : imperf: subj{np(str)} + {cp(że)}
aprobować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
aranżować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
aranżować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
aranżować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
aranżować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
archaizować się: _: : imperf: subj{np(str)}
archaizować: _: : imperf: subj{np(str)} + obj{np(str)}
archiwizować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
archiwizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
aresztować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
argument: : : : {lexnp(gen,sg,'siła',natr)}
argument: : : : {possp} + {comprepnp(co do)}
argument: : : : {possp} + {comprepnp(na temat)}
argument: : : : {possp} + {comprepnp(w kwestii)}
argument: : : : {possp} + {comprepnp(w sprawie)}
argument: : : : {possp} + {comprepnp(w stosunku do)}
argument: : : : {possp} + {cp(jakoby)}
argument: : : : {possp} + {cp(że)}
argument: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
argument: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,że)}
argument: : : : {possp} + {prepnp(przeciw,dat); prepnp(za,inst); comprepnp(na rzecz); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby); prepncp(za,inst,że); prepncp(za,inst,żeby); preplexnp(na,acc,sg,'korzyść',atr)}
argument: : : : {possp} + {prepnp(z,inst)}
argumentować: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
argumentować: _: : imperf: subj{np(str)} + {cp(że)}
argumentować: _: : imperf: subj{np(str)} + {cp(żeby)}
argumentować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
argumentować: _: : imperf: subj{np(str)} + {or}
argumentować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
argumentować: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)}
aromatyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
artykuł: : : : {possp} + {comprepnp(co do)}
artykuł: : : : {possp} + {comprepnp(w kwestii)}
artykuł: : : : {possp} + {comprepnp(w sprawie)}
artykuł: : : : {possp} + {cp(że)}
artykuł: : : : {possp} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)}
artykułować się: _: : imperf: subj{np(str)}
artykułować: _: : imperf: subj{np(str)} + {cp(int)}
artykułować: _: : imperf: subj{np(str)} + {cp(że)}
artykułować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
artykułować: _: : imperf: subj{np(str)} + {or}
aspirować: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
asygnować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
asygnować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
asygnować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
asygnować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
asygnować: _: : _: subj{np(str)} + obj{np(str)} + {xp(adl)}
asystować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc); prepncp(przy,loc,jak)}
asystować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
asystować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
asystować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
atak: : : : {np(inst)} + {possp} + {comprepnp(w stosunku do)}
atak: : : : {np(inst)} + {possp} + {prepnp(na,acc)}
atak: : : : {np(inst)} + {possp} + {prepnp(przeciw,dat)}
atak: : : : {np(inst)} + {possp} + {prepnp(wobec,gen)}
atak: : : : {possp} + {prepnp(na,acc)} + {xp(perl)}
atakować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
atakować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
atakować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
automatyzować się: _: : imperf: subj{np(str)}
automatyzować: _: : imperf: subj{np(str)} + obj{np(str)}
autoryzować: _: : _: subj{np(str)} + obj{np(str)}
awansować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
awansować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
awanturować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
awanturować się: _: : imperf: subj{np(str)} + {cp(int)}
awanturować się: _: : imperf: subj{np(str)} + {cp(że)}
awanturować się: _: : imperf: subj{np(str)} + {or}
awanturować się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
baczny: : : : {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
baczyć: _: : imperf: subj{np(str)} + {cp(int)}
baczyć: _: : imperf: subj{np(str)} + {cp(że)}
baczyć: _: : imperf: subj{np(str)} + {cp(żeby)}
baczyć: _: : imperf: subj{np(str)} + {np(gen)}
baczyć: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
bać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
bać się: _: : imperf: subj{np(str)} + {cp(int)}
bać się: _: : imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
bać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {cp(żeby)}
bać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
badać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
badać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
badać się: _: : imperf: subj{np(str)} + {xp(locat)}
badać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
badać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(inst)}
badać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
badać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
badać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
badać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
badać: _: : imperf: subj{np(str)} + {or}
badanie: : : : {np(gen); adjp(agr); prepnp(dla,gen); prepnp(nad,inst); comprepnp(na temat); comprepnp(w kwestii); ncp(gen,int); prepncp(nad,inst,int); preplexnp(w,loc,sg,'zakres',atr); preplexnp(z,gen,sg,'zakres',atr)} + {possp}
badanie: : : : {np(gen); adjp(agr); prepnp(na,acc); preplexnp(w,loc,sg,'kierunek',atr)} + {possp}
badanie: : : : {possp} + {cp(int)}
badanie: : : : {possp} + {prepnp(przeciw,dat)}
bagatelizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
bajka: : : : {fixed('o żelaznym wilku')}
bajka: : : : {possp} + {comprepnp(na temat)}
bajka: : : : {possp} + {cp(int); cp(że)}
bajka: : : : {possp} + {cp(jakoby)}
bajka: : : : {possp} + {prepnp(dla,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)}
balansować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
balansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
balansować: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
balansować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
balansować: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
balansować: _: : imperf: subj{np(str)} + {prepnp(pomiędzy,inst)}
balsamować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
balsamować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
bałamucić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
bałamucić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
bałamucić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
bałamucić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
bałamucić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
bałamucić: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
bandażować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
bandażować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
bankrutować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
baraszkować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
barykadować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
barykadować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
barykadować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
bawić się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
bawić się: _: : imperf: subj{np(str)} + {cp(że)}
bawić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
bawić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
bawić się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
bawić: _: : imperf: subj{cp(gdy)} + {np(str)}
bawić: _: : imperf: subj{cp(int)} + {np(str)}
bawić: _: : imperf: subj{cp(jak)} + {np(str)}
bawić: _: : imperf: subj{cp(jeśli)} + {np(str)}
bawić: _: : imperf: subj{cp(kiedy)} + {np(str)}
bawić: _: : imperf: subj{np(str); cp(że); ncp(str,że)} + {np(str)}
bawić: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
bawić: _: : imperf: subj{np(str)} + {xp(locat)}
baza: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)}
baza: : : : {np(gen)} + {possp}
baza: : : : {possp} + {prepnp(pod,acc)}
baza: : : : {prepnp(dla,gen)}
baza: : : : {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
baza: : : : {prepnp(pod,acc); prepncp(pod,acc,żeby)}
bazgrać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
bazgrać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
bazgrać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
bazgrać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
bazgrać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
bazgrać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
bazgrać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
bazgrać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
bazować: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
bąkać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
bąkać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
bąkać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
bąkać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {comprepnp(na temat)}
bąkać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepadjp(po,postp)}
bąkać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
bąkać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
bąkać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepadjp(po,postp)}
bąkać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
bąkać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
bąkać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
bąkać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
bąknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
bąknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
bąknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
bąknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {comprepnp(na temat)}
bąknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepadjp(po,postp)}
bąknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
bąknąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
bąknąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepadjp(po,postp)}
bąknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
bąknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
bąknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
bąknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
beatyfikować: _: : _: subj{np(str)} + obj{np(str)}
bełkotać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(pod,inst,_,'nos',natr)}
bełkotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',atr)}
bełkotać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',atr)} + {or}
bełkotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',atr)}
bełkotać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'nos',natr)}
bełkotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
bełkotać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
bełkotać: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,_,'nos',natr)} + {or}
bełkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
bełkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
bełkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
bełkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
bestwić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
bezbłędny: : : : {prepnp(przy,loc)}
bezbłędny: : : : {prepnp(w,loc)}
bezbronny: : : : {comprepnp(w stosunku do)}
bezbronny: : : : {prepnp(wobec,gen)}
bezbronny: : : : {prepnp(względem,gen)}
bezcenny: : : : {prepnp(dla,gen)} + {prepnp(przy,loc)}
bezcenny: : : : {prepnp(dla,gen)} + {prepnp(w,loc)}
bezcenny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
bezcenny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
bezcenny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
bezcenny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
bezcenny: : pred: : {prepnp(dla,gen)} + {cp(że)}
bezcześcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
bezdyskusyjny: : pred: : {cp(że)}
bezkrytyczny: : : : {prepnp(dla,gen)}
bezkrytyczny: : : : {prepnp(do,gen); comprepnp(w stosunku do)}
bezkrytyczny: : : : {prepnp(wobec,gen)}
bezkrytyczny: : : : {prepnp(względem,gen)}
bezlitosny: : : : {comprepnp(w stosunku do)}
bezlitosny: : : : {prepnp(dla,gen)}
bezlitosny: : : : {prepnp(wobec,gen)}
bezlitosny: : : : {prepnp(względem,gen)}
bezpieczny: : : : {prepnp(dla,gen)} + {prepnp(przy,loc)}
bezpieczny: : : : {prepnp(dla,gen)} + {prepnp(w,loc)}
bezpieczny: : : : {xp(locat)}
bezpośredni: : : : {prepnp(w,loc)}
bezradny: : : : {comprepnp(w stosunku do)}
bezradny: : : : {prepnp(wobec,gen); prepncp(wobec,gen,int); prepncp(wobec,gen,że)}
bezradny: : : : {prepnp(względem,gen)}
bezsensowny: : : : {prepnp(dla,gen)}
bezsensowny: : : : {prepnp(w,loc)}
bezsensowny: : pred: : {cp(gdy)}
bezsensowny: : pred: : {prepnp(dla,gen)} + {cp(int)}
bezsensowny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
bezsensowny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
bezsensowny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
bezsensowny: : pred: : {prepnp(dla,gen)} + {cp(że)}
bezsensowny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
bezsilny: : : : {comprepnp(w stosunku do)}
bezsilny: : : : {prepnp(wobec,gen); prepncp(wobec,gen,int); prepncp(wobec,gen,że)}
bezsilny: : : : {prepnp(względem,gen)}
bezsporny: : pred: : {cp(że)}
bezwzględny: : : : {comprepnp(w stosunku do)}
bezwzględny: : : : {prepnp(dla,gen)}
bezwzględny: : : : {prepnp(wobec,gen)}
bezwzględny: : : : {prepnp(względem,gen)}
bębnić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
bębnić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(w,acc,sg,'ucho',natr)}
bębnić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,sg,'ucho',natr)}
bębnić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
bębnić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
bębnić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
bębnić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
bębnić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
bębnić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
bić się: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(z,inst,pl,'myśl',natr)}
bić się: _: : imperf: subj{np(str)} + {preplexnp(w,acc,_,'pierś',natr)}
bić się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
bić się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
bić: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(str,_,'brawo',atr)}
bić: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(str,pl,'pokłon',atr)}
bić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
bić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
bić: _: : imperf: subj{np(str)} + {np(str)}
bić: _: : imperf: subj{np(str)} + obj{np(str)} + {fixed('na kwaśne jabłko')}
bić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'miazga',atr)}
bić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
bić: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'alarm',natr)}
bić: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
bić: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,_,'czoło',natr)}
bić: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(str,pl,'pokłon',atr)}
bić: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
bić: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
bić: _: : imperf: subj{np(str)} + {xp(abl)}
biec: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
biec: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
biec: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
biec: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
biedować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {xp(locat)}
biegać: _: : imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
biegać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
biegać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
biegać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
biegać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
biegły: : : : {prepnp(w,loc)}
bieleć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
bieleć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
bieleć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
bierny: : : : {comprepnp(w stosunku do)}
bierny: : : : {prepnp(wobec,gen)}
bierny: : : : {prepnp(względem,gen)}
biesiadować: _: : imperf: subj{np(str)}
bilansować się: _: : imperf: subj{np(str)} + {np(inst)}
bilansować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
bilansować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
bilansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
bilansować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
bilansować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
bilet: : : : {fixed('wilczy')}
bilet: : : : {np(gen)} + {possp} + {prepnp(do,gen); prepnp(na,acc)}
bitwa: : : : {adjp(agr); prepnp(o,acc); xp(locat)}
bitwa: : : : {possp} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)} + {xp(locat)}
bitwa: : : : {possp} + {prepnp(na,acc)} + {prepnp(przeciw,dat)} + {xp(locat)}
bitwa: : : : {prepnp(między,inst)} + {prepnp(na,acc)} + {prepnp(o,acc)} + {xp(locat)}
biwakować: _: : imperf: subj{np(str)} + {xp(locat)}
blamować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
blamować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
blednąć: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(przy,loc); prepncp(przy,loc,int); prepncp(przy,loc,że)}
blednąć: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(wobec,gen); prepncp(wobec,gen,int); prepncp(wobec,gen,że)}
blednąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
blednąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
blednąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
blefować: _: : imperf: subj{np(str)} + {comprepnp(co do)}
blefować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
blefować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
blefować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
blefować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
blefować: _: : imperf: subj{np(str)} + {or}
blefować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
blefować: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
bliski: : : : {comprepnp(w stosunku do)}
bliski: : : : {ncp(dat,że)}
bliski: : : : {np(dat); ncp(dat,int); ncp(dat,żeby)}
bliski: : : : {prepnp(do,gen)}
bliski: : : : {prepnp(od,gen)}
bliski: : : : {prepnp(względem,gen)}
bliski: : pred: : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
blokować się: _: : imperf: subj{np(str)} + {np(dat)}
blokować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
błagać: _: : imperf: subj{np(str)} + {np(gen)}
błagać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
błagać: _: : imperf: subj{np(str)} + {or}
błaźnić się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
błaźnić się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(wobec,gen)}
błaźnić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
błaźnić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
błądzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
błądzić: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
błądzić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
błądzić: _: : imperf: subj{np(str)} + {xp(perl)}
błąkać się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
błąkać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
błąkać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
błękitnieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
błękitnieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
błogosławić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
błogosławić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
błogosławić: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
błogosławić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
błogosławić: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
błyskać się: _: : imperf: subj{E}
błyskać się: _: : imperf: subj{np(str)}
błyskać: _: : imperf: subj{E}
błyskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
błyskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
błyskać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
błyskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
błyskać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
błyskać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
błysnąć się: _: : perf: subj{E}
błysnąć się: _: : perf: subj{np(str)}
błysnąć: _: : perf: {np(dat)} + {or}
błysnąć: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
błysnąć: _: : perf: subj{E}
błysnąć: _: : perf: subj{np(str)} + {comprepnp(na temat)}
błysnąć: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
błysnąć: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
błysnąć: _: : perf: subj{np(str)} + {cp(że)}
błysnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
błysnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
błysnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
błysnąć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
błysnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
błysnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
błysnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
błysnąć: _: : perf: subj{np(str)} + {or}
błyszczeć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
błyszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
bobrować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
bobrować: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
boczyć się: _: : imperf: subj{np(str)} + {prepncp(na,acc,że)}
boczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
boczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
boczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
boczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
bodnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
bodnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
bodnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
bogacić się: _: : imperf: subj{np(str)} + {np(inst)}
bogacić się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
bogacić się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
bogacić się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
bogacić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
bogacić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
bogacić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
bogaty: : : : {np(inst); ncp(inst,int); ncp(inst,że)}
bogaty: : : : {preplexnp(z,gen,sg,'dom',natr)}
bogaty: : : : {prepnp(o,acc); prepncp(o,acc,że)}
bogaty: : : : {prepnp(w,acc)}
bogaty: : : : {prepnp(w,loc)}
boksować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
boksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
boksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
boksować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
boleć: _: : imperf: {np(str)} + {comprepnp(z powodu)} + {xp(locat)}
boleć: _: : imperf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
boleć: _: : imperf: {np(str)} + {prepnp(z,gen)} + {xp(locat)}
boleć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
boleć: _: : imperf: subj{cp(gdy)} + {np(str)}
boleć: _: : imperf: subj{cp(int)} + {np(str)}
boleć: _: : imperf: subj{cp(jak)} + {np(str)}
boleć: _: : imperf: subj{cp(jeśli)} + {np(str)}
boleć: _: : imperf: subj{cp(kiedy)} + {np(str)}
boleć: _: : imperf: subj{cp(że)} + {np(str)}
boleć: _: : imperf: subj{lexnp(str,sg,'głowa',natr)} + {np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
boleć: _: : imperf: subj{np(str)} + {cp(że)}
boleć: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
boleć: _: : imperf: subj{np(str)} + {np(str)} + {comprepnp(z powodu)}
boleć: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
boleć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
boleć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
boleć: _: : imperf: subj{np(str)} + {or}
boleć: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
bolesny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
bolesny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
bolesny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
bolesny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
bolesny: : pred: : {prepnp(dla,gen)} + {cp(że)}
bombardować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
bombardować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {xp(abl)}
bombardować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
bonować: _: : imperf: subj{np(str)} + obj{np(str)}
bootować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
bootować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
borykać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
bożyć się: _: : imperf: subj{np(str)} + {cp(że)}
ból: : : : {lexnp(gen,sg,'istnienie',natr)}
ból: : : : {np(gen)} + {possp} + {cp(jakby)}
ból: : : : {np(gen)} + {possp} + {cp(że)}
ból: : : : {np(gen); prepnp(w,loc)} + {possp} + {comprepnp(z powodu)}
ból: : : : {np(gen); prepnp(w,loc)} + {possp} + {prepnp(od,gen)}
ból: : : : {np(gen); prepnp(w,loc)} + {possp} + {prepnp(po,loc)}
bóść się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
bóść: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
bóść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
brać się: _: : imperf: subj{np(str)} + {preplexnp(w,acc,pl,'karb',natr)}
brać się: _: : imperf: subj{np(str)} + {preplexnp(w,acc,sg,'garść',natr)}
brać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
brać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
brać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
brać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
brać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
brać się: _: : imperf: subj{np(str)} + {xp(abl)}
brać: _: : imperf: {np(str)} + {prepnp(na,acc)}
brać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(do,gen,_,'siebie',natr)}
brać: _: : imperf: subj{np(str)} + {lexnp(part,sg,'woda',natr)} + {preplexnp(w,acc,pl,'usta',natr)}
brać: _: : imperf: subj{np(str)} + {ncp(str,że)} + {preplexnp(do,gen,_,'siebie',natr)}
brać: _: : imperf: subj{np(str)} + {ncp(str,że)} + {preplexnp(na,acc,_,'siebie',natr)}
brać: _: : imperf: subj{np(str)} + {np(str)}
brać: _: : imperf: subj{np(str)} + {np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(do,gen)} + {lexnp(dat,_,'siebie',natr)}
brać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(do,gen,_,'siebie',natr)}
brać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(na,acc,_,'siebie',natr)}
brać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
brać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
brać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
brać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {preplexnp(pod,acc,sg,'uwaga',atr)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
brać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
brać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
brać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,sg,'góra',natr)}
brać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'łapa',natr)}
brać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'skóra',natr)}
brać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
brać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(str,sg,'ślub',atr)}
brak: _: : imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
brak: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
brak: _: : imperf: {np(dat)} + {prepnp(dla,gen); prepncp(dla,gen,int)} + {lexnp(gen,pl,'słowo',atr)}
brak: _: : imperf: {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int)} + {lexnp(gen,pl,'słowo',atr)}
brak: _: : imperf: {np(dat)} + {prepnp(wobec,gen)} + {lexnp(gen,pl,'słowo',atr)}
brak: _: : imperf: {np(gen)} + {xp(locat)}
braknąć: _: : imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
braknąć: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
braknąć: _: : imperf: {np(dat)} + {prepnp(dla,gen); prepncp(dla,gen,int)} + {lexnp(gen,pl,'słowo',atr)}
braknąć: _: : imperf: {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int)} + {lexnp(gen,pl,'słowo',atr)}
braknąć: _: : imperf: {np(dat)} + {prepnp(wobec,gen)} + {lexnp(gen,pl,'słowo',atr)}
braknąć: _: : imperf: {np(gen)} + {xp(locat)}
brakować: _: : imperf: {np(dat)} + {cp(żeby)}
brakować: _: : imperf: {np(dat)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
brakować: _: : imperf: {np(dat)} + {prepnp(dla,gen); prepncp(dla,gen,int)} + {lexnp(gen,pl,'słowo',atr)}
brakować: _: : imperf: {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int)} + {lexnp(gen,pl,'słowo',atr)}
brakować: _: : imperf: {np(dat)} + {prepnp(wobec,gen)} + {lexnp(gen,pl,'słowo',atr)}
brama: : : : {np(gen)} + {possp}
brama: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,żeby)}
brama: : : : {possp} + {prepnp(na,acc)}
brama: : : : {possp} + {prepnp(od,gen)}
bratać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
bratać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
bredzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
brnąć: _: : imperf: subj{np(str)} + {cp(że)}
brnąć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
brnąć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
brnąć: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
brnąć: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
brnąć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
broczyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
broczyć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
broczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
broczyć: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
broić: _: : imperf: subj{np(str)} + {nonch}
bronić się: _: : imperf: subj{np(str)} + {cp(że)}
bronić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
bronić się: _: : imperf: subj{np(str)} + {or}
bronić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
bronić: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
bronić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
bronić: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
bronić: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
bronić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
bronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
bronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
brudzić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
brudzić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
brudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
brudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
brukować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
brylować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(locat)}
brylować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
brząkać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
brząkać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
brząkać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
brząknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
brząknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
brząknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
brzemienny: : : : {np(inst)}
brzemienny: : : : {prepnp(w,acc)}
brzemienny: : : : {prepnp(w,loc)}
brzęknąć: _: : perf: subj{np(str)} + {cp(że)}
brzęknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
brzęknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
brzęknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
brzmieć: _: : imperf: controller{np(dat)} + controllee{xp(mod)} + {preplexnp(w,loc,pl,'ucho',natr)}
brzmieć: _: : imperf: subj,controller{np(str)} + controllee{np(nom)}
brzmieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'usta',ratr)}
brzmieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',ratr)}
brzmieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(dla,gen)}
brzmieć: _: : imperf: subj,controller{np(str); ncp(str,że)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',ratr)}
brzmieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(w,loc,pl,'ucho',ratr)}
brzmieć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
brzydzić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
brzydzić się: _: : imperf: subj{np(str)} + {cp(że)}
brzydzić się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
brzydzić się: _: : imperf: subj{np(str)} + {np(inst); ncp(gen,int); ncp(inst,że)}
brzydzić: _: : imperf: subj{cp(gdy)} + {np(str)}
brzydzić: _: : imperf: subj{cp(jak)} + {np(str)}
brzydzić: _: : imperf: subj{cp(kiedy)} + {np(str)}
brzydzić: _: : imperf: subj{cp(że)} + {np(str)}
brzydzić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
brzydzić: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
buchać: _: : imperf: {np(inst)} + {prepnp(od,gen)}
buchać: _: : imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
buchać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
buchnąć: _: : perf: {np(inst)} + {prepnp(od,gen)}
buchnąć: _: : perf: {np(inst)} + {xp(abl)} + {xp(adl)}
buchnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
buchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
buchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
buchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
budować się: _: : imperf: subj{np(str)} + {xp(locat)}
budować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
budować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
budujący: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
budujący: : pred: : {prepnp(dla,gen)} + {cp(jak)}
budujący: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
budujący: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
budujący: : pred: : {prepnp(dla,gen)} + {cp(że)}
budzić się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
budzić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
budzić się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
budzić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
budzić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
budzić się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
budzić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
budzić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
budzić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + obj{np(str)} + {prepnp(w,loc)}
budzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
budzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
budzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
budzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
budzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
budzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
bujać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
bujać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
bujać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
bujać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
bujać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
bujać: _: : imperf: {np(inst)}
bujać: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
bujać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
bujać: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
bujać: _: : imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
bujać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
bujać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
bujać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
bujać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
bujać: _: : imperf: subj{np(str)} + {or}
bujać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
bulić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
bulić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
bulwersować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
bulwersować się: _: : imperf: subj{np(str)} + {cp(int)}
bulwersować się: _: : imperf: subj{np(str)} + {cp(że)}
bulwersować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
bulwersować się: _: : imperf: subj{np(str)} + {or}
bulwersować: _: : imperf: subj{cp(gdy)} + {np(str)}
bulwersować: _: : imperf: subj{cp(int)} + {np(str)}
bulwersować: _: : imperf: subj{cp(jak)} + {np(str)}
bulwersować: _: : imperf: subj{cp(jeśli)} + {np(str)}
bulwersować: _: : imperf: subj{cp(kiedy)} + {np(str)}
bulwersować: _: : imperf: subj{cp(że)} + {np(str)}
bulwersować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
bulwersować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
bumelować: _: : imperf: subj{np(str)}
bunt: : : : {np(gen)} + {possp}
bunt: : : : {possp} + {comprepnp(na rzecz)}
bunt: : : : {possp} + {comprepnp(w kwestii)}
bunt: : : : {possp} + {comprepnp(w stosunku do)}
bunt: : : : {possp} + {cp(że)}
bunt: : : : {possp} + {cp(żeby)}
bunt: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,że)}
bunt: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
bunt: : : : {possp} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)}
bunt: : : : {possp} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {preplexnp(w,acc,sg,'imię',atr)}
bunt: : : : {possp} + {prepnp(wobec,gen); prepncp(wobec,gen,int); prepncp(wobec,gen,że); prepncp(wobec,gen,żeby)}
bunt: : : : {possp} + {prepnp(względem,gen); prepncp(względem,gen,że)}
buntować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
buntować się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {prepnp(w,loc)}
buntować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
buntować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
buntować się: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
buntować: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {cp(żeby)}
buntować: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
buntować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
burczeć: _: : imperf: {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
burczeć: _: : imperf: subj{np(str)} + {np(str)} + {comprepnp(na temat)}
burczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
burczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
burczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
burczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
burczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
burczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
burczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
burknąć: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
burknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
burknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
burknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby)}
burknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
burknąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby)}
burknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
burknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
burknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
burknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
burknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
burknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
burknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
burknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
burknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
burzyć się: _: : imperf: subj{np(str)} + {cp(że)}
burzyć się: _: : imperf: subj{np(str)} + {or}
burzyć się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
burzyć się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że)}
burzyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
burzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
burzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
burzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
buszować: _: : imperf: subj{np(str)} + {prepnp(po,loc); xp(locat)}
butwieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
butwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
butwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
butwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
butwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
buzować: _: : imperf: subj{np(str)} + {xp(locat)}
być: _: : imperf: controller{np(dat)} + controllee{infp(_)} + {advp(misc)}
być: _: : imperf: {np(dat)} + {cp(że)} + {advp(misc)}
być: _: : imperf: {prepnp(z,inst)} + {advp(misc)}
być: _: : imperf: subj,controller{cp(gdy)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(gdy)} + controllee{np(inst)}
być: _: : imperf: subj,controller{cp(int)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(int)} + controllee{np(inst)}
być: _: : imperf: subj,controller{cp(jak)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(jak)} + controllee{np(inst)}
być: _: : imperf: subj,controller{cp(jakoby)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(jakoby)} + controllee{np(inst)}
być: _: : imperf: subj,controller{cp(jeśli)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(jeśli)} + controllee{np(inst)}
być: _: : imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(kiedy)} + controllee{np(inst)}
być: _: : imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(żeby)} + controllee{np(inst)}
być: _: : imperf: subj,controller{cp(że)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{cp(że)} + controllee{np(inst)}
być: _: : imperf: subj,controller{infp(_)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{infp(_)} + controllee{np(inst)}
być: _: : imperf: subj,controller{lexnp(str,_,'powód',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{lexnp(str,sg,'okazja',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{lexnp(str,sg,'pomysł',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{lexnp(str,sg,'potrzeba',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{lexnp(str,sg,'rozkaz',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{lexnp(str,sg,'sens',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{lexnp(str,sg,'sposób',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{lexnp(str,_,'szansa',atr)} + controllee{infp(_)}
być: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
być: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(w,loc,sg,'stan',natr)}
być: _: : imperf: subj,controller{np(str)} + controllee{np(nom)}
być: _: : imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jakoby); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
być: _: : imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jakoby); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
być: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'zdanie',atr)}
być: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
być: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)}
być: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
być: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
być: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
być: _: : imperf: subj{np(str)} + {xp(locat)}
być: _: : imperf: subj{np(str)} + {xp(temp)}
bywać: _: : imperf: controller{np(dat)} + controllee{infp(_)} + {advp(misc)}
bywać: _: : imperf: {np(dat)} + {cp(że)} + {advp(misc)}
bywać: _: : imperf: {prepnp(z,inst)} + {advp(misc)}
bywać: _: : imperf: subj,controller{cp(gdy)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{cp(gdy)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{cp(int)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{cp(int)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{cp(jak)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{cp(jak)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{cp(jeśli)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{cp(jeśli)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{cp(kiedy)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{cp(żeby)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{cp(że)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{cp(że)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{infp(_)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{infp(_)} + controllee{np(inst)}
bywać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
bywać: _: : imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
bywać: _: : imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
bywać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'zdanie',atr)}
bywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
bywać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
bywać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {xp(temp)}
bywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
bywać: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
całować się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
całować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
całować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
całować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
całować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {preplexnp(z,gen,sg,'dubeltówka',natr)}
całować: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
całować: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
cały: : : : {adjp(agr)}
cały: : : : {prepnp(w,loc)}
cecha: : : : {ncp(gen,że)}
cecha: : : : {np(gen)}
cecha: : : : {possp} + {cp(że)}
cechować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
cechować: _: : imperf: subj{cp(że)} + {np(str)}
cechować: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
cechować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
cechować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cechować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
cedzić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
cedzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {or}
cedzić: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {cp(że)}
cel: : : : {cp(że)}
cel: : : : {cp(żeby)}
cel: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)}
cel: : : : {possp} + {prepnp(do,gen)}
cel: : : : {possp} + {prepnp(na,acc)}
celebrować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
celować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
celować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
celować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
celować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
celowy: : pred: : {cp(gdy)}
celowy: : pred: : {cp(jak)}
celowy: : pred: : {cp(jeśli)}
celowy: : pred: : {cp(kiedy)}
celowy: : pred: : {cp(że)}
celowy: : pred: : {cp(żeby)}
cena: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)} + {possp}
cena: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
cena: : : : {possp} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
cenić się: _: : imperf: subj{np(str)} + {advp(misc)}
cenić: _: : imperf: subj{np(str)} + {cp(że)} + {advp(misc)} + {lexnp(dat,_,'siebie',natr)}
cenić: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)} + {advp(misc)} + {lexnp(dat,_,'siebie',natr)}
cenić: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)} + {prepnp(u,gen)} + {advp(misc)}
cenić: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)} + {advp(misc)}
cenić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {advp(misc)}
cenić: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)} + {advp(misc)}
cenić: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)} + {advp(misc)}
cenny: : : : {prepnp(dla,gen)} + {prepnp(przy,loc)}
cenny: : : : {prepnp(dla,gen)} + {prepnp(w,loc)}
cenny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
cenny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
cenny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
cenny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
cenny: : pred: : {prepnp(dla,gen)} + {cp(że)}
centralizować się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
centralizować się: _: : imperf: subj{np(str)} + {xp(locat)}
centralizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
cenzurować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
cenzurować: _: : imperf: subj{np(str)} + {refl}
cerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
certyfikować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
certyfikować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
chadzać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
chadzać: _: : imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
chadzać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
chadzać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
chadzać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
charakterystyczny: : : : {prepnp(dla,gen)}
charakterystyczny: : pred: : {prepnp(dla,gen)} + {cp(int)}
charakterystyczny: : pred: : {prepnp(dla,gen)} + {cp(że)}
charakteryzować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
charakteryzować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {refl}
charakteryzować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {refl}
charakteryzować: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
charakteryzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
charakteryzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
charakteryzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
charakteryzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
charchać: _: : imperf: subj{np(str)}
chcieć się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
chcieć się: _: : imperf: {np(dat)} + {np(gen)}
chcieć: _: : imperf: subj,controller{np(str)} + controllee{np(str); cp(żeby); infp(_); advp(misc)}
chcieć: _: : imperf: subj{np(str)} + {cp(że)}
chcieć: _: : imperf: subj{np(str)} + {np(gen); cp(żeby); ncp(gen,żeby)} + {prepnp(od,gen)}
chcieć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
chcieć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc)}
chcieć: _: : imperf: subj{np(str)} + {or}
chcieć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
chcieć: _: : imperf: subj{np(str)} + {xp(adl)}
chciwy: : : : {np(gen); ncp(gen,żeby)}
chciwy: : : : {prepnp(na,acc)}
chełpić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)} + {prepnp(przed,inst)}
chełpić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
chełpić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(jak)}
chełpić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
chełpić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
chętny: : : : {cp(żeby)}
chętny: : : : {np(dat)}
chętny: : : : {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
chętny: : : : {prepnp(ku,dat)}
chętny: : : : {xp(adl)}
chichotać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
chichotać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
chichotać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
chichotać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
chichotać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
chichotać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
chlać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
chlać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
chlać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
chlapać się: _: : imperf: subj{np(str)} + {xp(locat)}
chlapać: _: : imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
chlapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
chlapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
chlapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
chlapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
chlapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
chlapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
chlapać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chlapać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
chlapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chlapnąć: _: : perf: {np(inst)} + {xp(abl)} + {xp(adl)}
chlapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
chlapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
chlapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
chlapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
chlapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
chlapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
chlapnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
chlapnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
chlapnąć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
chlapnąć: _: : perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
chlapnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chlorkować: _: : imperf: subj{np(str)} + obj{np(str)}
chlorować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
chlubić się: _: : imperf: subj{np(str)} + {cp(że)}
chlubić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
chlubić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
chlupać: _: : imperf: {np(dat)} + {xp(locat)}
chlupać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
chlupać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chlupać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
chlupać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
chlupać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
chlupnąć: _: : perf: {np(dat)} + {xp(locat)}
chlupnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
chlupnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
chlupnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
chlupnąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
chlupnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
chłeptać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
chłonąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
chłonąć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(perl)}
chłosnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
chłosnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
chłosnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chłosnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chłosnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
chłostać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
chłostać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
chłostać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chłostać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chłostać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
chodzić: _: : imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
chodzić: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
chodzić: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
chodzić: _: : imperf: subj{cp(żeby)} + {prepnp(za,inst)}
chodzić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
chodzić: _: : imperf: subj{cp(że)} + {prepnp(za,inst)}
chodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
chodzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(koło,gen)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'łóżka',natr)}
chodzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'para',atr)}
chodzić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
chorować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
chorować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
chory: : : : {preplexnp(na,loc,sg,'umysł',natr)}
chory: : : : {preplexnp(z,gen,sg,'urojenie',natr)}
chory: : : : {prepnp(na,acc); prepncp(na,acc,że)} + {comprepnp(z powodu)}
chory: : : : {prepnp(od,gen); prepncp(od,gen,że)}
chory: : : : {prepnp(z,gen)}
chory: : pred: : {cp(gdy)}
chory: : pred: : {cp(jak)}
chory: : pred: : {cp(kiedy)}
chory: : pred: : {cp(że)}
chory: : pred: : {cp(żeby)}
chować się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
chować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
chować się: _: : imperf: subj{np(str)} + {prepnp(z,inst); xp(locat)} + {advp(misc)}
chować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(adl)}
chować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
chować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
chować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
chować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)} + {refl}
chować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
chrapać: _: : imperf: subj{np(str)}
chromować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
chronić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
chronić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
chronić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
chronić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
chronić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
chronić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
chronić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {refl}
chronić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {refl}
chronić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
chronić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
chronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
chronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
chrupać: _: : imperf: {np(dat)} + {xp(locat)}
chrupać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chrupać: _: : imperf: subj{np(str)} + {np(inst)}
chrupać: _: : imperf: subj{np(str)} + obj{np(str)}
chrupnąć: _: : perf: {np(dat)} + {xp(locat)}
chrupnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
chrupnąć: _: : perf: subj{np(str)} + {np(inst)}
chrupnąć: _: : perf: subj{np(str)} + obj{np(str)}
chrzanić się: _: : imperf: subj{cp(int)} + {np(dat)}
chrzanić się: _: : imperf: subj{cp(że)} + {np(dat)}
chrzanić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
chrzanić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
chrzanić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
chrzanić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
chrzanić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
chrzanić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
chrzcić się: _: : imperf: subj{np(str)}
chrzcić: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
chrzcić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
chrzcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chrzęścić: _: : imperf: {np(dat)} + {xp(locat)}
chrzęścić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chrzęścić: _: : imperf: subj{np(str)} + {np(inst)}
chuchać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
chuchać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
chuchać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
chuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
chuchnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
chuchnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
chudnąć: _: : imperf: subj{np(str)} + {np(str)}
chudnąć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
chudnąć: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
chudnąć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
chwalebny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
chwalebny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
chwalebny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
chwalebny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
chwalebny: : pred: : {prepnp(dla,gen)} + {cp(że)}
chwalić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); cp(że); ncp(inst,że)}
chwalić się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
chwalić się: _: : imperf: subj{np(str)} + {np(inst); cp(że); ncp(inst,że)} + {prepnp(przed,inst)}
chwalić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
chwalić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
chwalić się: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
chwalić: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
chwalić: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
chwalić: _: : imperf: subj{np(str)} + {np(str); ncp(str,że)}
chwalić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
chwalić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
chwalić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
chwalić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
chwalić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
chwalić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
chwila: : : : {cp(aż)}
chwila: : : : {cp(że)}
chwila: : : : {cp(żeby)}
chwila: : : : {np(gen)} + {possp}
chwila: : : : {prepnp(na,acc); prepncp(na,acc,żeby)}
chwila: : : : {prepnp(z,inst)}
chwila: : : : {xp(temp)}
chwycić się: _: : perf: subj{np(str)} + {np(gen)}
chwycić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
chwycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
chwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
chwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
chwycić: _: : perf: subj{np(str)} + {prepnp(pod,acc)} + {refl}
chwytać się: _: : imperf: subj{np(str)} + {np(gen)}
chwytać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
chwytać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
chwytać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
chwytać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
chybiać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'cel',natr)}
chybiać: _: : imperf: subj{np(str)} + {np(gen)}
chybić: _: : perf: subj{np(str)} + {lexnp(gen,sg,'cel',natr)}
chybić: _: : perf: subj{np(str)} + {np(gen)}
chylić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
chylić się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
chylić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
chylić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
chylić się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
chylić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
chylić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
chylić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
chylić się: _: : imperf: subj{np(str)} + {xp(adl)}
chylić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
chylić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
chylić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
chylić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
chylić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
chylić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
chylić: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {lexnp(gen,sg,'czoło',natr)}
chylić: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {lexnp(str,sg,'czoło',natr)}
chylić: _: : imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,int); prepncp(przed,inst,że)} + {lexnp(gen,sg,'czoło',natr)}
chylić: _: : imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,int); prepncp(przed,inst,że)} + {lexnp(str,sg,'czoło',natr)}
chytry: : : : {np(gen)}
chytry: : : : {prepnp(na,acc)}
ciasny: : : : {prepnp(dla,gen)}
ciąć się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
ciąć: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ciąć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ciąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepnp(w,acc)}
ciąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ciągać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ciągać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
ciągać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
ciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(adl)}
ciągnąć się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
ciągnąć się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
ciągnąć się: _: : imperf: subj{np(str)} + {xp(dur)}
ciągnąć się: _: : imperf: subj{np(str)} + {xp(perl)}
ciągnąć: _: : imperf: {np(inst)} + {prepnp(od,gen)}
ciągnąć: _: : imperf: {np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ciągnąć: _: : imperf: subj{np(str)} + {cp(że)}
ciągnąć: _: : imperf: subj{np(str)} + {np(str)} + {or}
ciągnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
ciągnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
ciągnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
ciągnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
ciągnąć: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
ciążyć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
ciążyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
ciążyć: _: : imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
ciążyć: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
cichnąć: _: : imperf: subj{np(str)}
cichnąć: _: : imperf: {xp(locat)}
ciec: _: : imperf: {np(dat)} + {xp(abl)}
ciec: _: : imperf: {np(dat)} + {xp(adl)}
ciec: _: : imperf: {np(dat)} + {xp(perl)}
ciec: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(adl)}
ciec: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ciekawić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ciekawić: _: : imperf: subj{cp(że)} + {np(str)}
ciekawić: _: : imperf: subj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(str)}
ciekawy: : : : {comprepnp(co do)}
ciekawy: : : : {comprepnp(na temat)}
ciekawy: : : : {np(gen); ncp(gen,int); ncp(gen,że)}
ciekawy: : : : {prepnp(do,gen)}
ciekawy: : : : {prepnp(w,loc)}
ciekawy: : pred: : {cp(gdy)}
ciekawy: : pred: : {cp(int)}
ciekawy: : pred: : {cp(jak)}
ciekawy: : pred: : {cp(jeśli)}
ciekawy: : pred: : {cp(kiedy)}
ciekawy: : pred: : {cp(że)}
ciemiężyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cieniować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
cień: : : : {np(gen); ncp(gen,int)}
cień: : : : {possp} + {preplexnp(pod,inst,_,'oko',atr)}
cień: : : : {possp} + {prepnp(do,gen)}
cień: : : : {possp} + {xp(locat)}
cierpieć: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
cierpieć: _: : imperf: subj{np(str)} + {cp(że)}
cierpieć: _: : imperf: subj{np(str)} + {np(str)}
cierpieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
cierpieć: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
cierpieć: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
cierpieć: neg: : imperf: subj,controller{np(str)} + controllee{infp(_)}
cierpieć: neg: : imperf: subj{np(str)} + {cp(gdy)}
cierpieć: neg: : imperf: subj{np(str)} + {cp(jak)}
cierpieć: neg: : imperf: subj{np(str)} + {cp(jeśli)}
cierpieć: neg: : imperf: subj{np(str)} + {cp(kiedy)}
cierpieć: neg: : imperf: subj{np(str)} + {cp(że)}
cierpieć: neg: : imperf: subj{np(str)} + {cp(żeby2)}
cierpieć: neg: : imperf: subj{np(str)} + {np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)}
cierpienie: : : : {possp} + {comprepnp(z powodu)}
cierpienie: : : : {possp} + {prepnp(na,acc)}
cierpienie: : : : {possp} + {prepnp(od,gen)}
cierpienie: : : : {possp} + {prepnp(po,loc)}
cierpienie: : : : {possp} + {prepnp(za,acc)}
cierpnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
cierpnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
cieszyć się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
cieszyć się: _: : imperf: subj{np(str)} + {cp(że)}
cieszyć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
cieszyć się: _: : imperf: subj{np(str)} + {or}
cieszyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
cieszyć się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
cieszyć: _: : imperf: subj{cp(gdy)} + {np(str)}
cieszyć: _: : imperf: subj{cp(int)} + {np(str)}
cieszyć: _: : imperf: subj{cp(jak)} + {np(str)}
cieszyć: _: : imperf: subj{cp(jeśli)} + {np(str)}
cieszyć: _: : imperf: subj{cp(kiedy)} + {np(str)}
cieszyć: _: : imperf: subj{cp(że)} + {np(str)}
cieszyć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
cieszyć: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
ciężki: : : : {preplexnp(na,loc,_,'umysł',natr)}
ciężki: : : : {prepnp(dla,gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ciężki: : : : {prepnp(w,loc)}
ciężki: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
ciężki: : pred: : {prepnp(dla,gen)} + {cp(jak)}
ciężki: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
ciężki: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
ciężki: : pred: : {prepnp(dla,gen)} + {cp(że)}
ciężki: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
ciosać: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'kołek',natr)} + {np(dat)} + {preplexnp(na,loc,sg,'głowa',natr)}
ciosać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ciosać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ciosać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ciosać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ciskać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
ciskać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ciskać się: _: : imperf: subj{np(str)} + {xp(adl)}
ciskać: _: : imperf: {np(inst)} + {prepnp(o,acc)}
ciskać: _: : imperf: {np(inst)} + {xp(adl)}
ciskać: _: : imperf: {np(str)} + {cp(że)}
ciskać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
ciskać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
ciskać: _: : imperf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
ciskać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
ciskać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
ciskać: _: : imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
ciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
ciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
cisnąć się: _: : perf: subj{np(str)} + {xp(adl)}
cisnąć się: _: : imperf: subj{cp(int)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
cisnąć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: _: : imperf: subj{np(str)} + {xp(adl)}
cisnąć się: _: : imperf: subj{np(str)} + {xp(locat)}
cisnąć się: _: : imperf: subj{or} + {np(dat)} + {prepnp(na,acc)}
cisnąć: _: : perf: {np(inst)} + {prepnp(o,acc)}
cisnąć: _: : perf: {np(inst)} + {xp(adl)}
cisnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
cisnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
cisnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
cisnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
cisnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
cisnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
cisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
cisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
cisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
cisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
cisnąć: _: : imperf: {np(str)} + {xp(locat)}
cisnąć: _: : imperf: subj{cp(żeby)} + {np(str)}
cisnąć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
cisnąć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
cisnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
cisnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
cisnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cisnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
cisnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
cisza: : : : {comprepnp(co do)}
cisza: : : : {comprepnp(na temat)}
cisza: : : : {comprepnp(w kwestii)}
cisza: : : : {comprepnp(w sprawie)}
cisza: : : : {fixed('grobowa')}
cisza: : : : {preplexnp(przed,inst,sg,'burza',natr)}
cisza: : : : {prepnp(wokół,gen)}
cisza: : : : {xp(locat)}
ciułać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ciułać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
ciułać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
cmokać: _: : imperf: subj{np(str)} + {np(inst)}
cmokać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
cmokać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
cmokać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
cmokać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
cmokać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
cmokać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
cmoknąć: _: : perf: subj{np(str)} + {np(inst)}
cmoknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
cmoknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
cmoknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
cmoknąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
cmoknąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
co: : : : {cp(że)}
co: : : : {np(dat)} + {prepnp(z,gen); prepncp(z,gen,że)}
cofać się: _: : imperf: subj{np(str)} + {np(dat)}
cofać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
cofać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
cofać się: _: : imperf: subj{np(str)} + {prepncp(przed,inst,żeby)}
cofać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
cofać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
cofać się: _: : imperf: subj{np(str)} + {xp(abl)}
cofać się: _: : imperf: subj{np(str)} + {xp(adl)}
cofać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
cofać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
cofać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
cofać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
cofać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
cofać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
cofnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
cofnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
cofnąć się: _: : perf: subj{np(str)} + {prepncp(przed,inst,żeby)}
cofnąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
cofnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofnąć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
cofnąć się: _: : perf: subj{np(str)} + {xp(abl)}
cofnąć się: _: : perf: subj{np(str)} + {xp(adl)}
cofnąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofnąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
cofnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
cofnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
cofnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
cofnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
cofnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
cokolwiek: : : : {prepnp(z,gen); prepncp(z,gen,że)}
coś: : : : {fixed('niecoś')}
coś: : : : {prepnp(z,gen); prepncp(z,gen,że)}
cóż: : : : {cp(że)}
cóż: : : : {cp(że)} + {fixed('stąd')}
cóż: : : : {np(dat)} + {prepnp(z,gen); prepncp(z,gen,że)}
cuchnąć: _: : imperf: controller{np(dat)} + controllee{xp(mod)} + {xp(abl)}
cuchnąć: _: : imperf: controller{prepnp(od,gen)} + controllee{xp(mod)}
cuchnąć: _: : imperf: controller{xp(locat)} + controllee{xp(mod)}
cuchnąć: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)}
cuchnąć: _: : imperf: {np(inst)} + {prepnp(od,gen)}
cuchnąć: _: : imperf: {np(inst)} + {xp(locat)}
cuchnąć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
cuchnąć: _: : imperf: subj{np(str)} + {np(inst)}
cucić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
cucić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
cud: : : : {cp(że)}
cud: : : : {cp(żeby)}
cud: : : : {np(gen)}
cudowny: : pred: : {cp(gdy)}
cudowny: : pred: : {cp(jak)}
cudowny: : pred: : {cp(jeśli)}
cudowny: : pred: : {cp(kiedy)}
cudowny: : pred: : {cp(że)}
cumować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
cumować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
cwałować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
cyfrować: _: : imperf: subj{np(str)} + obj{np(str)}
cyklinować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cynować: _: : imperf: subj{np(str)} + obj{np(str)}
cytować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)} + {or}
cytować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {or}
cytować: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
cytować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
cywilizować się: _: : imperf: subj{np(str)}
cywilizować: _: : imperf: subj{np(str)} + obj{np(str)}
cyzelować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
czaić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
czaić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
czaić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
czaić się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
czaić się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
czaić: _: : imperf: subj{np(str)} + {cp(int)}
czaić: _: : imperf: subj{np(str)} + {cp(że)}
czaić: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
czapkować: _: : imperf: subj{np(str)} + {np(dat)}
czapkować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
czarować: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
czarować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
czarować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
czarować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
czarterować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
czarterować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
czarterować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
czarterować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
czarterować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
czas: _: : imperf: controller{np(dat)} + controllee{infp(_)}
czas: _: : imperf: {np(dat)} + {xp(adl)}
czas: _: : imperf: {prepnp(na,acc)} + {cp(żeby)}
czas: _: : imperf: {prepnp(na,acc); prepncp(na,acc,żeby)}
czatować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
czatować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
czatować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
czatować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
czatować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
czcić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
czcić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
czcić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
czekać: _: : imperf: subj{np(str)} + {np(gen)}
czekać: _: : imperf: subj{np(str)} + {np(str)}
czekać: _: : imperf: subj{np(str)} + {prepnp(na,acc); cp(aż); cp(int); cp(jak); cp(kiedy); cp(że); cp(żeby); prepncp(na,acc,aż); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,kiedy); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)} + {xp(dur)}
czekać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(aż)} + {xp(dur)}
czekać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(dur)} + {xp(locat)}
czepiać się: _: : imperf: subj{np(str)} + {np(gen)} + {cp(int); cp(że)}
czepiać się: _: : imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że)}
czepiać się: _: : imperf: subj{np(str)} + {np(gen)} + {np(inst)}
czepiać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
czepiać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
czepiać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
czepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
czepić się: _: : perf: subj{np(str)} + {np(gen)} + {cp(int); cp(że)}
czepić się: _: : perf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że)}
czepić się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
czepić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
czepić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
czepić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
czepić: _: : imperf: subj{np(str)} + obj{np(str)}
czernić się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
czernić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
czerpać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(z,gen)}
czerpać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
czerpać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {lexnp(inst,_,'garść',atr)}
czerwienić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
czerwienić się: _: : imperf: subj{np(str)} + {np(inst)}
czerwienić się: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
czerwienić: _: : imperf: subj{np(str)} + obj{np(str)}
czesać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
czesać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
czesać się: _: : imperf: subj{np(str)} + {xp(locat)}
czesać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
czesać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
czesać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
cześć: : : : {np(gen)}
cześć: : : : {prepnp(dla,gen)}
cześć: : : : {prepnp(do,gen)}
cześć: : : : {prepnp(z,gen)}
częstować się: _: : imperf: subj{np(str)} + {np(inst)}
częstować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
część: : : : {np(gen)} + {comprepnp(co do)}
część: : : : {np(gen)} + {comprepnp(w sprawie)}
część: : : : {np(gen)} + {possp} + {prepnp(do,gen)}
część: : : : {np(gen)} + {prepnp(dla,gen)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
część: : : : {prepnp(z,gen)}
czołgać się: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,loc)}
czołgać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
czołgać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
czuć się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
czuć się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(na,loc,_,'siła',natr)}
czuć się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
czuć się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
czuć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
czuć się: _: : imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
czuć się: _: : imperf: subj{np(str)} + {np(gen)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
czuć: _: : imperf: {cp(int)} + {xp(locat)}
czuć: _: : imperf: {cp(jak)} + {xp(locat)}
czuć: _: : imperf: {cp(że)} + {xp(locat)}
czuć: _: : imperf: {np(inst)} + {np(str)}
czuć: _: : imperf: {np(inst)} + {prepnp(od,gen)}
czuć: _: : imperf: {np(str)} + {prepnp(od,gen)}
czuć: _: : imperf: {np(str)} + {xp(locat)}
czuć: _: : imperf: subj{np(str)} + {cp(int)}
czuć: _: : imperf: subj{np(str)} + {cp(jakby)}
czuć: _: : imperf: subj{np(str)} + {cp(jak); cp(że)}
czuć: _: : imperf: subj{np(str)} + {cp(jakoby)}
czuć: _: : imperf: subj{np(str)} + {cp(żeby2)}
czuć: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',atr)}
czuć: _: : imperf: subj{np(str)} + {np(str); ncp(str,jak); ncp(str,że); ncp(str,żeby2)}
czuć: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(przez,acc,sg,'skóra',natr)}
czuć: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(w,loc,pl,'kość',natr)}
czuć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
czuć: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
czuć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,sg,'mięta',natr)}
czujny: : : : {comprepnp(w stosunku do)}
czujny: : : : {cp(czy)}
czujny: : : : {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,żeby)}
czujny: : : : {prepnp(wobec,gen)}
czujny: : : : {prepnp(względem,gen)}
czulić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
czuły: : : : {comprepnp(w stosunku do)}
czuły: : : : {prepnp(dla,gen)}
czuły: : : : {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
czuły: : : : {prepnp(względem,gen)}
czuwać: _: : imperf: subj{np(str)} + {cp(żeby)}
czuwać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
czuwać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
czuwać: _: : imperf: subj{np(str)} + {xp(locat)}
czyhać: _: : imperf: subj{np(str)} + {cp(żeby)}
czyhać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
czynić się: _: : imperf: {advp(misc)}
czynić się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
czynić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
czynić: _: : imperf: subj{np(str); ncp(str,że)} + controller{np(str)} + controllee{adjp(inst)}
czynić: _: : imperf: subj{np(str); ncp(str,że)} + controller{np(str)} + controllee{np(inst)}
czynić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
czynić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
czynić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
czynić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
czynny: : : : {prepnp(w,loc)}
czynny: : : : {xp(temp)}
czyścić się: _: : imperf: subj{np(str)}
czyścić: _: : imperf: {np(str)}
czyścić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
czyścić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
czyścić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
czytać: _: : imperf: subj{np(str)} + {cp(żeby)}
czytać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
czytać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
czytać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
czytać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
czytać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
czytać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
czytać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(int)}
czytać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
czytać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {or}
czytywać: _: : imperf: subj{np(str)} + {cp(że)}
czytywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
czytywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
czytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
czytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ćpać: _: : imperf: subj{np(str)} + obj{np(str)}
ćwiartować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
ćwiczyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
ćwiczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ćwiczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ćwiczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ćwiczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ćwierkać: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
ćwierkać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
ćwierkać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)} + {preplexnp(do,gen,sg,'ucho',natr)}
ćwierkać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
ćwierkać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,jak); prepncp(o,loc,że)}
ćwierknąć: _: : perf: subj{cp(że)} + {np(dat)} + {xp(locat)}
ćwierknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
ćwierknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)} + {preplexnp(do,gen,sg,'ucho',natr)}
ćwierknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
ćwierknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,jak); prepncp(o,loc,że)}
dachować: _: : imperf: subj{np(str)}
dać się: _: : perf: {infp(_)}
dać się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(w,acc,pl,'znak',natr)}
dać się: _: : perf: subj{np(str)} + {np(dat)}
dać: _: : perf: {infp(_)} + {lexnp(str,sg,'rada',natr)}
dać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rada',natr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'czas',atr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'możliwość',natr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'okazja',atr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'prawo',atr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,_,'szansa',atr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'imię',natr)}
dać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)} + {preplexnp(na,acc,sg,'imię',natr)}
dać: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(str,sg,'rada',natr)}
dać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(str,sg,'głowa',natr)}
dać: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
dać: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'myślenie',natr)}
dać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'słowo',atr)}
dać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {lexnp(str,sg,'słowo',atr)}
dać: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
dać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
dać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
dać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
dać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
dać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
daleki: : : : {np(dat); ncp(dat,żeby)}
daleki: : : : {prepncp(od,gen,że)}
daleki: : : : {prepnp(dla,gen)}
daleki: : : : {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,żeby)}
dana: : : : {adjp(agr)} + {possp} + {comprepnp(na temat)}
dana: : : : {adjp(agr)} + {possp} + {comprepnp(w kwestii)}
dana: : : : {adjp(agr)} + {possp} + {comprepnp(w sprawie)}
dana: : : : {adjp(agr)} + {possp} + {cp(int)}
dana: : : : {adjp(agr)} + {possp} + {cp(jakoby)}
dana: : : : {adjp(agr)} + {possp} + {cp(że)}
dana: : : : {adjp(agr)} + {possp} + {cp(żeby)}
dana: : : : {adjp(agr)} + {possp} + {preplexnp(w,loc,sg,'zakres',atr)}
dana: : : : {adjp(agr)} + {possp} + {preplexnp(z,gen,sg,'dziedzina',atr)}
dana: : : : {adjp(agr)} + {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że); prepncp(co do,gen,żeby)}
dana: : : : {adjp(agr)} + {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby); preplexnp(z,gen,sg,'zakres',atr)}
dana: : : : {possp} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
dar: : : : {possp} + {comprepnp(na rzecz)}
dar: : : : {possp} + {cp(żeby)}
dar: : : : {possp} + {prepnp(dla,gen)}
dar: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dar: : : : {possp} + {prepnp(na,acc)}
dar: : : : {possp} + {prepnp(z,gen)}
dar: : : : {prepnp(dla,gen)} + {prepnp(od,gen)}
darować: _: : _: subj{np(str)} + {np(dat)} + {cp(że)}
darować: _: : _: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
darzyć się: _: : imperf: {np(dat)} + {advp(misc)}
darzyć się: _: : imperf: {np(dat)} + {prepnp(w,loc)}
darzyć się: _: : imperf: {np(dat)} + {xp(locat)}
darzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
darzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
datować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
datować się: _: : imperf: subj{np(str)} + {xp(temp)}
datować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
datować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
dawać się: _: : imperf: {infp(_)}
dawać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(w,acc,pl,'znak',natr)}
dawać się: _: : imperf: subj{np(str)} + {np(dat)}
dawać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rada',natr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'czas',atr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'możliwość',natr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'okazja',natr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'prawo',natr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,_,'szansa',atr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'imię',natr)}
dawać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)} + {preplexnp(na,acc,sg,'imię',natr)}
dawać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(str,sg,'rada',natr)}
dawać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(str,sg,'głowa',natr)}
dawać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
dawać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'myślenie',natr)}
dawać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'słowo',atr)}
dawać: _: : imperf: subj{np(str)} + {np(dat)} + {np(part)}
dawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {lexnp(str,sg,'słowo',atr)}
dawać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
dawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
dawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
dawkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dąć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dąć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
dąć się: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
dąć: _: : imperf: {np(inst)} + {xp(locat)}
dąć: _: : imperf: subj{np(str)} + {np(inst)}
dąć: _: : imperf: subj{np(str)} + obj{np(str)}
dąć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
dąć: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
dąć: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dąć: _: : imperf: subj{np(str)} + {xp(perl)}
dąsać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
dąsać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
dąsać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
dąsać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dążyć: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dążyć: _: : imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
dążyć: _: : imperf: subj{np(str)} + {xp(adl)}
dbać: _: : imperf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
debata: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)}
debata: : : : {possp} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)} + {comprepnp(w kwestii)}
debata: : : : {possp} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)} + {comprepnp(w sprawie)}
debata: : : : {possp} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)} + {cp(int)}
debata: : : : {possp} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)} + {prepncp(nad,inst,że)}
debata: : : : {possp} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)} + {prepncp(nad,inst,żeby)}
debata: : : : {possp} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)} + {prepnp(nad,inst); prepnp(o,loc); prepnp(wokół,gen); comprepnp(na temat); prepncp(nad,inst,int); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby); prepncp(wokół,gen,int)}
debatować: _: : imperf: subj{np(str)} + {or}
debatować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); comprepnp(na temat); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
debatować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
debatować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
debatować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
debatować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
debiutować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(inst)} + {prepnp(przed,inst)} + {xp(locat)}
decydować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
decydować się: _: : imperf: subj{np(str)} + {cp(int)}
decydować się: _: : imperf: subj{np(str)} + {cp(że)}
decydować się: _: : imperf: subj{np(str)} + {cp(żeby)}
decydować się: _: : imperf: subj{np(str)} + {or}
decydować się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
decydować: _: : imperf: subj{np(str)} + {advp(pron)}
decydować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
decydować: _: : imperf: subj{np(str)} + {cp(int)}
decydować: _: : imperf: subj{np(str)} + {cp(że)}
decydować: _: : imperf: subj{np(str)} + {cp(żeby)}
decydować: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
decydować: _: : imperf: subj{np(str)} + {or}
decydować: _: : imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
decyzja: : : : {possp} + {comprepnp(w stosunku do)}
decyzja: : : : {possp} + {cp(int)}
decyzja: : : : {possp} + {cp(że)}
decyzja: : : : {possp} + {cp(żeby)}
decyzja: : : : {possp} + {or}
decyzja: : : : {possp} + {prepnp(co do,gen); prepnp(o,loc); comprepnp(na temat); comprepnp(w kwestii); comprepnp(w sprawie); prepncp(co do,gen,int); prepncp(co do,gen,że); prepncp(co do,gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
decyzja: : : : {possp} + {prepnp(przeciw,dat); prepnp(za,inst)}
decyzja: : : : {possp} + {prepnp(wobec,gen)}
decyzja: : : : {possp} + {prepnp(wokół,gen)}
decyzja: : : : {possp} + {prepnp(względem,gen)}
dedykować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat); prepnp(dla,gen)}
deficytowy: : : : {prepnp(w,acc)}
definiować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
definiować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
definiować: _: : imperf: subj{np(str)} + obj{cp(int)}
definiować: _: : imperf: subj{np(str)} + obj{cp(że)}
definiować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
definiować: _: : imperf: subj{np(str)} + {or}
deformować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
deformować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
degenerować się: _: : imperf: subj{np(str)}
degenerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
degradować się: _: : imperf: subj{np(str)} + {advp(misc)}
degradować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
degradować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
degradować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
degradować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
degustować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dekatyzować: _: : imperf: subj{np(str)} + obj{np(str)}
deklamować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
deklamować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
deklamować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
deklaracja: : : : {np(gen); ncp(gen,int); ncp(gen,że)}
deklaracja: : : : {possp} + {comprepnp(w kwestii)}
deklaracja: : : : {possp} + {comprepnp(w sprawie)}
deklaracja: : : : {possp} + {cp(int)}
deklaracja: : : : {possp} + {cp(że)}
deklaracja: : : : {possp} + {or}
deklaracja: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
deklaracja: : : : {possp} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)}
deklarować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
deklarować się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
deklarować się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
deklarować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
deklarować się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
deklarować się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
deklarować się: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
deklarować się: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
deklarować się: _: : imperf: subj{np(str)} + {cp(int)}
deklarować się: _: : imperf: subj{np(str)} + {cp(że)}
deklarować się: _: : imperf: subj{np(str)} + {cp(żeby)}
deklarować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
deklarować się: _: : imperf: subj{np(str)} + {or}
deklarować się: _: : imperf: subj{np(str)} + {preplexnp(po,loc,sg,'strona',ratr)}
deklarować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
deklarować się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
deklarować się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)}
deklarować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
deklarować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
deklarować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
deklarować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
deklarować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
dekodować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dekorować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
delegacja: : : : {adjp(agr)} + {prepnp(dla,gen)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
delegacja: : : : {adjp(agr)} + {prepnp(dla,gen)} + {prepnp(o,loc)}
delegacja: : : : {cp(że)}
delegacja: : : : {np(gen)} + {possp} + {prepnp(do,gen)} + {xp(abl)} + {xp(adl)}
delegacja: : : : {np(gen)} + {possp} + {prepnp(na,acc)} + {xp(abl)} + {xp(adl)}
delegacja: : : : {possp} + {prepnp(za,acc)}
delegacja: : : : {prepnp(dla,gen)} + {comprepnp(w kwestii)}
delegacja: : : : {prepnp(dla,gen)} + {cp(żeby)}
delegacja: : : : {prepnp(dla,gen)} + {preplexnp(w,loc,sg,'zakres',atr)}
delegacja: : : : {prepnp(na,acc)} + {prepnp(od,gen)}
delektować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
dementować: _: : imperf: subj{np(str)} + {cp(jakoby)}
dementować: _: : imperf: subj{np(str)} + {cp(że)}
dementować: _: : imperf: subj{np(str)} + {cp(żeby)}
dementować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,jakoby); ncp(str,że); ncp(str,żeby)}
dementować: _: : imperf: subj{np(str)} + {or}
demolować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
demonizować: _: : imperf: subj{np(str)} + {cp(int)}
demonizować: _: : imperf: subj{np(str)} + {cp(że)}
demonizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
demonstrować: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
demonstrować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
demonstrować: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
demonstrować: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(wobec,gen)}
demonstrować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
demonstrować: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
demonstrować: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(wobec,gen)}
demonstrować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
demonstrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
demonstrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
demonstrować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
demonstrować: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
demontować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
demontować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
demoralizować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
demoralizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
denerwować się: _: : imperf: subj{np(str)} + {cp(int)}
denerwować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
denerwować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
denerwować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
denerwować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
denerwować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
denerwować się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
denerwować: _: : imperf: subj{cp(gdy)} + {np(str)}
denerwować: _: : imperf: subj{cp(int)} + {np(str)}
denerwować: _: : imperf: subj{cp(jak)} + {np(str)}
denerwować: _: : imperf: subj{cp(jeśli)} + {np(str)}
denerwować: _: : imperf: subj{cp(kiedy)} + {np(str)}
denerwować: _: : imperf: subj{cp(że)} + {np(str)}
denerwować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
denerwować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
deponować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
deportować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
desantować się: _: : _: subj{np(str)} + {xp(abl)} + {xp(abl)}
desantować się: _: : _: subj{np(str)} + {xp(abl)} + {xp(locat)}
desantować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
desantować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(locat)}
destabilizować się: _: : imperf: subj{np(str)}
destabilizować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
destabilizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
destylować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
desygnować: _: : _: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
desygnować: _: : _: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
desygnować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
detonować się: _: : imperf: subj{np(str)} + {np(inst)}
detonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
detonować: _: : imperf: subj{np(str)} + {refl}
dewastować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dezorientować się: _: : imperf: subj{np(str)}
dezorientować: _: : imperf: subj{cp(gdy)} + {np(str)}
dezorientować: _: : imperf: subj{cp(int)} + {np(str)}
dezorientować: _: : imperf: subj{cp(jak)} + {np(str)}
dezorientować: _: : imperf: subj{cp(jeśli)} + {np(str)}
dezorientować: _: : imperf: subj{cp(kiedy)} + {np(str)}
dezorientować: _: : imperf: subj{cp(że)} + {np(str)}
dezorientować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
dezorientować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
diagnozować: _: : imperf: subj{np(str)} + {cp(int)}
diagnozować: _: : imperf: subj{np(str)} + {cp(że)}
diagnozować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(u,gen)}
diagnozować: _: : imperf: subj{np(str)} + {or}
diagnozować: _: : imperf: subj{np(str)} + {refl}
dławić się: _: : imperf: subj{np(str)} + {np(inst)} + {or}
dławić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dławić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
dławić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dłubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
dłubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
dłubać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
dłużny: : : : {comprepnp(w stosunku do)}
dłużny: : : : {np(acc)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
dłużny: : : : {np(dat)} + {prepnp(w,loc)}
dłużny: : : : {prepnp(wobec,gen)}
dłużny: : : : {prepnp(względem,gen)}
dmuchać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
dmuchać: _: : imperf: {np(inst)}
dmuchać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
dmuchać: _: : imperf: subj{np(str)} + obj{np(str)}
dmuchać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dmuchnąć: _: : perf: {np(inst)}
dmuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {or}
dmuchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dmuchnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
dmuchnąć: _: : perf: subj{np(str)} + {xp(adl)}
dobić się: _: : perf: subj{np(str)} + {np(gen)}
dobić: _: : perf: subj{cp(gdy)} + {np(str)}
dobić: _: : perf: subj{cp(jak)} + {np(str)}
dobić: _: : perf: subj{cp(jeśli)} + {np(str)}
dobić: _: : perf: subj{cp(kiedy)} + {np(str)}
dobić: _: : perf: subj{cp(że)} + {np(str)}
dobić: _: : perf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(str)}
dobić: _: : perf: subj{np(str)} + obj{lexnp(gen,sg,'targ',natr)} + {prepnp(z,inst)}
dobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
dobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
dobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dobić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dobiec: _: : perf: subj{cp(jak)} + {np(gen)} + {xp(abl)}
dobiec: _: : perf: subj{cp(jak)} + {prepnp(do,gen)} + {xp(abl)}
dobiec: _: : perf: subj{cp(że)} + {np(gen)} + {xp(abl)}
dobiec: _: : perf: subj{cp(że)} + {prepnp(do,gen)} + {xp(abl)}
dobiec: _: : perf: subj{np(str)} + {np(gen)} + {xp(abl)}
dobiec: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)}
dobiec: _: : perf: subj{np(str)} + {np(str)} + {xp(perl)}
dobiec: _: : perf: subj{np(str); or} + {np(gen)} + {xp(abl)}
dobiec: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
dobiec: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)}
dobiec: _: : perf: subj{np(str)} + {xp(adl)}
dobiec: _: : perf: subj{or} + {np(str)} + {xp(abl)}
dobiec: _: : perf: subj{or} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{cp(jak)} + {np(gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{cp(jak)} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{cp(że)} + {np(gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{cp(że)} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{cp(że)} + {prepnp(do,gen)} + {xp(perl)}
dobiegać: _: : imperf: subj{np(str)} + {np(gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{np(str)} + {np(str)} + {xp(abl)}
dobiegać: _: : imperf: subj{np(str); or} + {np(gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)}
dobiegać: _: : imperf: subj{np(str)} + {xp(adl)}
dobiegać: _: : imperf: subj{or} + {np(str)} + {xp(abl)}
dobiegać: _: : imperf: subj{or} + {prepnp(do,gen)} + {xp(abl)}
dobierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobierać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
dobierać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(abl)} + {lexnp(dat,_,'siebie',natr)}
dobierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobijać się: _: : imperf: subj{np(str)} + {np(gen)}
dobijać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
dobijać: _: : imperf: subj{cp(gdy)} + {np(str)}
dobijać: _: : imperf: subj{cp(jak)} + {np(str)}
dobijać: _: : imperf: subj{cp(jeśli)} + {np(str)}
dobijać: _: : imperf: subj{cp(kiedy)} + {np(str)}
dobijać: _: : imperf: subj{cp(że)} + {np(str)}
dobijać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(str)}
dobijać: _: : imperf: subj{np(str)} + obj{lexnp(gen,sg,'targ',natr)} + {prepnp(z,inst)}
dobijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
dobijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
dobijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dobijać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dobrać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
dobrać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobrać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
dobrać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)} + {lexnp(dat,_,'siebie',natr)}
dobrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobrnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dobrnąć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
dobry: : : : {lexnp(dat,_,'siebie',natr)}
dobry: : : : {preplexnp(z,inst,pl,'kość',natr)}
dobry: : : : {prepnp(dla,gen); prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
dobry: : : : {prepnp(o,acc)} + {prepnp(w,loc); prepncp(w,loc,że)}
dobry: : : : {xp(locat); xp(temp)}
dobry: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
dobry: : pred: : {prepnp(dla,gen)} + {cp(jak)}
dobry: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
dobry: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
dobry: : pred: : {prepnp(dla,gen)} + {cp(że)}
dobry: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
dobudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dobudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dobyć się: _: : perf: subj{np(str)} + {xp(abl)}
dobyć: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)}
dobywać się: _: : imperf: subj{np(str)} + {xp(abl)}
dobywać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(abl)}
doceniać: _: : imperf: subj{np(str)} + {cp(int)}
doceniać: _: : imperf: subj{np(str)} + {cp(że)}
doceniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
doceniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
doceniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
doceniać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
docenić: _: : perf: subj{np(str)} + {cp(int)}
docenić: _: : perf: subj{np(str)} + {cp(że)}
docenić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
docenić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
docenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
docenić: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
dochować się: _: : perf: subj{np(str)} + {np(gen)}
dochować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dochować: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(do,gen)}
dochować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dochowywać się: _: : imperf: subj{np(str)} + {np(gen)}
dochowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dochowywać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(do,gen)}
dochowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dochód: : : : {adjp(agr)} + {possp} + {prepnp(od,gen); prepnp(z,gen); prepnp(za,acc); prepncp(z,gen,że); preplexnp(z,gen,sg,'tytuł',atr)} + {prepnp(za,acc)} + {preplexnp(w,loc,sg,'wysokość',atr)}
dochód: : : : {adjp(agr)} + {prepnp(dla,gen)} + {prepnp(od,gen); prepnp(z,gen); prepnp(za,acc); prepncp(z,gen,że); preplexnp(z,gen,sg,'tytuł',atr)} + {prepnp(za,acc)} + {preplexnp(w,loc,sg,'wysokość',atr)}
dochód: : : : {possp} + {prepnp(na,acc)} + {preplexnp(w,loc,sg,'wysokość',atr)}
dochód: : : : {prepnp(poniżej,gen)}
dochód: : : : {prepnp(powyżej,gen)}
dociąć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
dociąć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
dociąć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
dociąć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
dociąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
dociąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
dociąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dociągać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dociągać się: _: : imperf: subj{np(str)} + {xp(adl)}
dociągać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'żywot',atr)}
dociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
dociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dociągnąć się: _: : perf: subj{np(str)} + {np(gen)}
dociągnąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dociągnąć się: _: : perf: subj{np(str)} + {xp(adl)}
dociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
dociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dociec: _: : perf: subj{np(str)} + {cp(int)}
dociec: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int)}
dociec: _: : perf: subj{np(str)} + {or}
dociec: _: : perf: subj{np(str)} + {xp(adl)}
dociekać: _: : imperf: subj{np(str)} + {cp(int)}
dociekać: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int)}
dociekać: _: : imperf: subj{np(str)} + {or}
dociekać: _: : imperf: subj{np(str)} + {xp(adl)}
docieplić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
docierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
docierać: _: : imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
docierać: _: : imperf: subj{np(str)} + {np(part)}
docierać: _: : imperf: subj{np(str)} + obj{np(str)}
docierać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
docinać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
docinać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
docinać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
docinać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
docinać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
docinać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
docinać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
doczekać się: _: : perf: subj{np(str)} + {cp(aż)}
doczekać się: _: : perf: subj{np(str)} + {cp(int)}
doczekać się: _: : perf: subj{np(str)} + {cp(jak)}
doczekać się: _: : perf: subj{np(str)} + {cp(że)}
doczekać się: _: : perf: subj{np(str)} + {cp(żeby)}
doczekać się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
doczekać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,aż); prepncp(na,acc,że); prepncp(na,acc,żeby)}
doczekać: _: : perf: subj{np(str)} + {cp(aż)}
doczekać: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)}
doczekać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dodać: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
dodać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dodać: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {prepnp(do,gen)}
dodać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
dodatek: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
dodatek: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen); prepncp(do,gen,int)}
dodatek: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)} + {prepnp(na,acc)}
dodatek: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)}
dodatek: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)} + {prepnp(za,acc)}
dodatek: : : : {prepnp(dla,gen)} + {prepnp(do,gen)} + {preplexnp(z,gen,sg,'tytuł',atr)}
dodawać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
dodawać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dodawać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {prepnp(do,gen)}
dodawać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
dodzwaniać się: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(adl)}
dodzwaniać się: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
dodzwaniać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dodzwonić się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(adl)}
dodzwonić się: _: : perf: subj{np(str)} + {prepnp(po,acc)}
dodzwonić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dofinansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dofinansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
dofinansowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dofinansowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
dogadać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
dogadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
dogadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
dogadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
dogadać: _: : perf: subj{np(str)} + {np(dat)} + {or}
dogadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dogadywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
dogadywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
dogadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
dogadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dogadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
dogadywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
dogadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dogadzać: _: : imperf: subj{cp(że)} + {np(dat)}
dogadzać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
dogadzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
dogadzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
doganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
doganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
doganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
doglądać: _: : imperf: subj{np(str)} + {cp(int)}
doglądać: _: : imperf: subj{np(str)} + {cp(jak)}
doglądać: _: : imperf: subj{np(str)} + obj{np(gen)}
dogmatyzować: _: : imperf: subj{np(str)} + obj{np(str)}
dogodny: : : : {np(dat)}
dogodny: : : : {prepnp(dla,gen)}
dogodny: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
dogodny: : : : {prepnp(ku,dat); prepncp(ku,dat,żeby)}
dogodny: : : : {prepnp(na,acc); prepncp(na,acc,żeby)}
dogodny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
dogodny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
dogodny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
dogodny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
dogodny: : pred: : {prepnp(dla,gen)} + {cp(że)}
dogodny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
dogodzić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
dogodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
dogonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dogonić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dogonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dogorywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dogorywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
dogotować się: _: : perf: subj{np(str)}
dogotować: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dogotowywać się: _: : imperf: subj{np(str)}
dogotowywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dograć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
dograć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dograć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
dograć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
dograć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
dograć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dogrywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
dogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
dogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
dogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
dogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
doholować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
doić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
doić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
doić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
doić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
doić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doić: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
doić: _: : imperf: subj{np(str)} + {xp(adl)}
doić: _: : imperf: subj{np(str)} + {xp(locat)}
doinwestować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
doinwestować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
dojadać: _: : imperf: subj{np(str)} + {np(dat)}
dojadać: _: : imperf: subj{np(str)} + {np(inst)}
dojadać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
dojadać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dojechać: _: : perf: subj{np(str)} + {np(dat)}
dojechać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dojechać: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dojechać: _: : perf: subj{np(str)} + obj{np(str)}
dojechać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dojeść: _: : perf: subj{np(str)} + {np(dat)}
dojeść: _: : perf: subj{np(str)} + {np(inst)}
dojeść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
dojeść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dojeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dojeżdżać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dojeżdżać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dojrzały: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
dojrzały: : : : {prepnp(na,acc); prepncp(na,acc,żeby)}
dojrzały: : pred: : {cp(gdy)}
dojrzały: : pred: : {cp(jak)}
dojrzały: : pred: : {cp(jeśli)}
dojrzały: : pred: : {cp(kiedy)}
dojrzały: : pred: : {cp(żeby)}
dojrzeć: _: : perf: subj{np(str)} + {cp(int)}
dojrzeć: _: : perf: subj{np(str)} + {cp(jak)}
dojrzeć: _: : perf: subj{np(str)} + {cp(że)}
dojrzeć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
dojrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dojrzeć: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dojrzewać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dojść: _: : perf: {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dojść: _: : perf: subj{cp(int)} + {prepnp(do,gen)}
dojść: _: : perf: subj{cp(że)} + {prepnp(do,gen)}
dojść: _: : perf: subj{np(str)} + {cp(int)}
dojść: _: : perf: subj{np(str)} + {cp(że)}
dojść: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
dojść: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
dojść: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'ład',natr)}
dojść: _: : perf: subj{np(str)} + {xp(adl)}
dokapitalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dokarmiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
dokarmiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
dokarmić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
dokarmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
dokazać: _: : perf: subj{np(str)} + {cp(że)}
dokazać: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dokazywać: _: : imperf: subj{np(str)} + {cp(że)}
dokazywać: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dokazywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
dokładać się: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dokładać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
dokładać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
dokładać: _: : imperf: subj{np(str)} + {np(gen)} + {cp(żeby)}
dokładać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dokonać się: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
dokonać: _: : perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dokonywać się: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
dokonywać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dokończyć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
dokończyć: _: : perf: subj{np(str)} + {cp(że)}
dokończyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dokończyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
dokrajać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dokręcać się: _: : imperf: subj{np(str)} + {np(dat)}
dokręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
dokręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dokręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dokręcić się: _: : perf: subj{np(str)} + {np(dat)}
dokręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dokręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dokręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dokroić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dokształcać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
dokształcać się: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
dokształcać się: _: : imperf: subj{np(str)} + {cp(int)}
dokształcać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dokształcać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
dokształcać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
dokształcać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
dokształcać się: _: : imperf: subj{np(str)} + {xp(locat)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dokształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dokształcić się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
dokształcić się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
dokształcić się: _: : perf: subj{np(str)} + {cp(int)}
dokształcić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
dokształcić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
dokształcić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
dokształcić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
dokształcić się: _: : perf: subj{np(str)} + {xp(locat)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dokuczać: _: : imperf: subj{cp(że)} + {np(dat)}
dokuczać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
dokuczać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
dokuczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dokuczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
dokuczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dokuczać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
dokuczyć: _: : perf: subj{cp(że)} + {np(dat)}
dokuczyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
dokuczyć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
dokuczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
dokuczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
dokuczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dokuczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
dokumentować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
dokumentować: _: : imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
dokupić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {prepnp(za,acc)}
dokupić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {xp(locat)}
dokupować: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {prepnp(za,acc)}
dokupować: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {xp(locat)}
dokupywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {prepnp(za,acc)}
dokupywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {xp(locat)}
dolać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dolatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dolatywać: _: : imperf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(perl)}
dolatywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
dolecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dolecieć: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(perl)}
dolecieć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
dolegać: _: : imperf: subj{np(str)} + {np(dat)}
dolewać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
doliczyć się: _: : perf: subj{np(str)} + {cp(int)}
doliczyć się: _: : perf: subj{np(str)} + {cp(że)}
doliczyć się: _: : perf: subj{np(str)} + {np(gen)}
doliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
doliczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dołączać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dołączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dołączyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dołączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dołożyć się: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dołożyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
dołożyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
dołożyć: _: : perf: subj{np(str)} + {np(gen)} + {cp(żeby)}
dołożyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
domagać się: _: : imperf: subj{np(str)} + {np(gen); cp(żeby); ncp(gen,żeby)} + {prepnp(od,gen)}
domalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
domalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
domalowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
domalowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
domierzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
domierzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dominować: _: : perf: subj{np(str)} + obj{np(str)}
dominować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
dominować: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
dominować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
domniemać: _: : perf: subj{np(str)} + {cp(int)}
domniemać: _: : perf: subj{np(str)} + {cp(że)}
domniemać: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
domniemać: _: : perf: subj{np(str)} + {or}
domniemać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
domniemywać: _: : imperf: subj{np(str)} + {cp(int)}
domniemywać: _: : imperf: subj{np(str)} + {cp(że)}
domniemywać: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
domniemywać: _: : imperf: subj{np(str)} + {or}
domniemywać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
domontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
domontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
domontowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
domontowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
domurować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
domyć się: _: : perf: subj{np(str)} + {np(gen)}
domyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,gen)}
domyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
domyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
domyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
domyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
domyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
domyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,gen)} + {refl}
domyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)} + {refl}
domyślać się: _: : imperf: subj{np(str)} + {cp(żeby)}
domyślać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
domyślać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(z,gen)}
domyślać się: _: : imperf: subj{np(str)} + {or}
domyślać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
domyślać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
domyślać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
domyślać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
domyśleć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
domyśleć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(z,gen)}
domyśleć się: _: : perf: subj{np(str)} + {or}
domyśleć się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
domyśleć się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
domyśleć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
domyśleć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
domyślić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
domyślić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(z,gen)}
domyślić się: _: : perf: subj{np(str)} + {or}
domyślić się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
domyślić się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
domyślić się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
domyślić się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
donieść się: _: : perf: subj{cp(że)} + {prepnp(do,gen)}
donieść się: _: : perf: subj{np(str)} + {xp(adl)}
donieść: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
donieść: _: : perf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
donieść: _: : perf: subj{np(str)} + {np(dat)} + {or}
donieść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
donieść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
donieść: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
donieść: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
donieść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
donieść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(jakoby)}
donieść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
donieść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
donosić się: _: : imperf: subj{np(str)} + {xp(abl)}
donosić: _: : perf: subj{np(str)} + obj{np(str)}
donosić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
donosić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
donosić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
donosić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
donosić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
donosić: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
donosić: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
donosić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
donosić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(jakoby)}
donosić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
donosić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
dookreślać: _: : imperf: subj{np(str)} + {cp(że)}
dookreślać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
dookreślać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
dookreślać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dookreślać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dookreślać: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)} + {refl}
dookreślić: _: : perf: subj{np(str)} + {cp(int)} + {refl}
dookreślić: _: : perf: subj{np(str)} + {cp(że)}
dookreślić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
dookreślić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
dookreślić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
dookreślić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dookreślić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dopadać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dopadać: _: : perf: {np(gen)}
dopadać: _: : perf: subj{np(str)} + {np(gen)}
dopadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dopadać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dopadać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dopakowywać: _: : imperf: subj{np(str)} + obj{np(str)}
dopasować się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopasowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopasowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopaść się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dopaść: _: : perf: subj{np(str)} + {np(gen)}
dopaść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dopaść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dopaść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dopatrywać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby2)} + {prepnp(w,loc); prepncp(w,loc,że)}
dopatrywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
dopatrywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
dopatrywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
dopatrywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby2)}
dopatrywać: _: : imperf: subj{np(str)} + {cp(int)}
dopatrywać: _: : imperf: subj{np(str)} + {cp(że)}
dopatrywać: _: : imperf: subj{np(str)} + {cp(żeby)}
dopatrywać: _: : imperf: subj{np(str)} + {np(gen)}
dopatrzyć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby2)} + {prepnp(w,loc); prepncp(w,loc,że)}
dopatrzyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
dopatrzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
dopatrzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
dopatrzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby2)}
dopatrzyć: _: : perf: subj{np(str)} + {cp(int)}
dopatrzyć: _: : perf: subj{np(str)} + {cp(że)}
dopatrzyć: _: : perf: subj{np(str)} + {cp(żeby)}
dopatrzyć: _: : perf: subj{np(str)} + {np(gen)}
dopełniać się: _: : imperf: subj{np(str)}
dopełniać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dopełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopełnić się: _: : perf: subj{np(str)}
dopełnić: _: : perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dopełnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopełzać: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
dopełznąć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
dopiec się: _: : perf: subj{np(str)}
dopiec: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
dopiec: _: : perf: subj{np(str)} + {np(dat)} + {fixed('do żywego')}
dopiec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
dopiec: _: : perf: subj{np(str)} + {np(dat)} + {or}
dopiec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dopiec: _: : perf: subj{np(str)} + obj{np(part)}
dopiekać się: _: : imperf: subj{np(str)}
dopiekać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dopiekać: _: : imperf: subj{np(str)} + {np(dat)} + {fixed('do żywego')}
dopiekać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
dopiekać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
dopiekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dopiekać: _: : imperf: subj{np(str)} + obj{np(part)}
dopierać się: _: : imperf: subj{np(str)} + {np(inst)}
dopierać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
dopierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dopieszczać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
dopieszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dopieścić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
dopieścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dopilnować: _: : perf: subj{np(str)} + obj{np(gen)} + {cp(int); cp(żeby)}
dopilnować: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
dopingować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {cp(żeby)}
dopingować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dopingować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
dopingować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
dopingować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
dopingować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dopingować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dopisać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dopisać: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(do,gen)}
dopisać: _: : perf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
dopisać: _: : perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(do,gen)}
dopisać: _: : perf: subj{np(str)} + obj{cp(żeby)} + {xp(locat)}
dopisać: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(do,gen)}
dopisać: _: : perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
dopisać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen)}
dopisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dopisać: _: : perf: subj{np(str)} + obj{or} + {prepnp(do,gen)}
dopisać: _: : perf: subj{np(str)} + obj{or} + {xp(locat)}
dopisywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dopisywać: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(do,gen)}
dopisywać: _: : imperf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
dopisywać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(do,gen)}
dopisywać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {xp(locat)}
dopisywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(do,gen)}
dopisywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
dopisywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen)}
dopisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
dopisywać: _: : imperf: subj{np(str)} + obj{or} + {prepnp(do,gen)}
dopisywać: _: : imperf: subj{np(str)} + obj{or} + {xp(locat)}
dopłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(z,gen)}
dopłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
dopłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
dopłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(z,gen)}
dopłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
dopłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
dopłynąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dopłynąć: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dopływać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dopływać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dopominać się: _: : imperf: subj{np(str)} + {cp(żeby)}
dopominać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
dopominać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
dopomnieć się: _: : perf: subj{np(str)} + {cp(żeby)}
dopomnieć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
dopomnieć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
dopomóc: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
dopomóc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
dopomóc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dopomóc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
dopomóc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
doposażyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
doposażyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
dopowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
dopowiadać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(do,gen)}
dopowiadać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(do,gen)}
dopowiadać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
dopowiadać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
dopowiedzieć: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(do,gen)}
dopracować się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dopracować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dopracowywać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dopracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dopraszać się: _: : imperf: subj{np(str)} + {np(gen)} + {cp(żeby)}
dopraszać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {prepnp(od,gen)}
dopraszać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {prepnp(u,gen)}
dopraszać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
dopraszać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {prepnp(od,gen)}
dopraszać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {prepnp(u,gen)}
dopraszać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(żeby)}
dopraszać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(żeby)}
dopraszać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {or}
dopraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
doprecyzować się: _: : perf: subj{np(str)}
doprecyzować: _: : perf: subj{np(str)} + obj{cp(int)}
doprecyzować: _: : perf: subj{np(str)} + obj{cp(że)}
doprecyzować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
doprecyzować: _: : perf: subj{np(str)} + {or}
doprecyzowywać się: _: : imperf: subj{np(str)}
doprecyzowywać: _: : imperf: subj{np(str)} + obj{cp(int)}
doprecyzowywać: _: : imperf: subj{np(str)} + obj{cp(że)}
doprecyzowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
doprecyzowywać: _: : imperf: subj{np(str)} + {or}
doprosić się: _: : perf: subj{np(str)} + {np(gen)} + {cp(żeby)}
doprosić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {prepnp(od,gen)}
doprosić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {prepnp(u,gen)}
doprosić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
doprosić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {prepnp(od,gen)}
doprosić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {prepnp(u,gen)}
doprosić się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(żeby)}
doprosić się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(żeby)}
doprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
doprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
doprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doprowadzać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
doprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
doprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doprowadzić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
doprząc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
doprzęgać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dopuszczać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że)}
dopuszczać: _: : imperf: subj{np(str)} + {cp(żeby)}
dopuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopuszczać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopuścić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)}
dopuścić: _: : perf: subj{np(str)} + {cp(żeby)}
dopuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopuścić: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopytać się: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {xp(locat)}
dopytać się: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
dopytać się: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
dopytać się: _: : perf: subj{np(str)} + {np(gen)} + {cp(int)}
dopytać się: _: : perf: subj{np(str)} + {np(gen)} + {or}
dopytać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
dopytać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
dopytać się: _: : perf: subj{np(str)} + {xp(locat)} + {or}
dopytać: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
dopytać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
dopytać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
dopytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
dopytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dopytać: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
dopytywać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {xp(locat)}
dopytywać się: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
dopytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {cp(int)}
dopytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {or}
dopytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
dopytywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
dopytywać się: _: : imperf: subj{np(str)} + {xp(locat)} + {or}
dopytywać: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
dopytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
dopytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
dopytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
dopytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dopytywać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
dorabiać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {np(inst); ncp(inst,że)}
dorabiać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
dorabiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
dorabiać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
doradzać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
doradzać: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
doradzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
doradzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
doradzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
doradzać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
doradzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
doradzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
doradzić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
doradzić: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
doradzić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
doradzić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
doradzić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
doradzić: _: : perf: subj{np(str)} + {np(dat)} + {or}
doradzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
doradzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
dorastać: _: : imperf: subj{np(str)} + {cp(żeby)}
dorastać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'pięta',natr)}
dorastać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {advp(misc)}
dorastać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
dorastać: _: : imperf: subj{np(str)} + {xp(locat)}
doregulować się: _: : perf: subj{np(str)}
doregulować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
doregulowywać się: _: : imperf: subj{np(str)}
doregulowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
doręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
doręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'ręka',batr)}
doręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
doręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'ręka',batr)}
doręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dorobić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {np(inst); ncp(inst,że)}
dorobić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
dorobić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
dorobić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dorosnąć: _: : perf: subj{np(str)} + {cp(żeby)}
dorosnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'pięta',natr)}
dorosnąć: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {advp(misc)}
dorosnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
dorosnąć: _: : perf: subj{np(str)} + {xp(locat)}
dorównać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
dorównać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dorównać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
dorównywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
dorównywać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dorównywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
dorwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dorwać się: _: : perf: subj{np(str)} + {np(gen)}
dorwać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
dorwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
dorwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dorysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dorysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dorysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
dorysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dorysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dorysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
dorywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dorywać się: _: : imperf: subj{np(str)} + {np(gen)}
dorywać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
dorywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
dorywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dorzucać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dorzucać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dorzucać: _: : imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
dorzucać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dorzucać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
dorzucać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(adl)}
dorzucać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
dorzucać: _: : imperf: subj{np(str)} + {or}
dorzucać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
dorzucać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
dorzucać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
dorzucić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dorzucić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
dorzucić: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
dorzucić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dorzucić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
dorzucić: _: : perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
dorzucić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
dorzucić: _: : perf: subj{np(str)} + {or}
dorzucić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
dorzucić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
dorzucić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
dosiadać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dosiadać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
dosiadać: _: : imperf: subj{np(str)} + obj{np(gen)}
dosiadywać: _: : imperf: subj{np(str)} + obj{np(str)}
dosiadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
dosiąść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dosiąść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
dosiąść: _: : perf: subj{np(str)} + {np(gen)}
dosiedzieć: _: : perf: subj{np(str)} + obj{np(str)}
dosiedzieć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
dosięgnąć: _: : perf: subj{np(str)} + {np(gen)}
dosięgnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dosięgnąć: _: : perf: subj{np(str)} + {np(str)} + {or}
dosięgnąć: _: : perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dosięgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
doskwierać: _: : imperf: subj{cp(że)} + {np(dat)}
doskwierać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
dosłać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dosłuchać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
dosłuchać: _: : perf: subj{np(str)} + obj{np(str)}
dosłuchiwać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
dosłuchiwać: _: : imperf: subj{np(str)} + obj{np(gen)}
dosłyszeć: _: : perf: subj{np(str)} + {cp(int)}
dosłyszeć: _: : perf: subj{np(str)} + {cp(jak)}
dosłyszeć: _: : perf: subj{np(str)} + {cp(że)}
dosłyszeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dosłyszeć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dosmażać się: _: : imperf: subj{np(str)}
dosmażać: _: : imperf: subj{np(str)} + obj{np(part)}
dosmażać: _: : imperf: subj{np(str)} + obj{np(str)}
dosmażyć się: _: : perf: subj{np(str)}
dosmażyć: _: : perf: subj{np(str)} + obj{np(part)}
dosmażyć: _: : perf: subj{np(str)} + obj{np(str)}
dostać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
dostać: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
dostać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'nakaz',natr)}
dostać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'polecenie',natr)}
dostać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dostać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'szansa',natr)}
dostać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'zadanie',natr)}
dostać: _: : perf: subj{np(str)} + {np(gen)}
dostać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dostać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dostać: _: : perf: subj{np(str)} + {np(part)} + {prepnp(od,gen)}
dostać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
dostarczać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
dostarczyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
dostateczny: : : : {cp(żeby)}
dostateczny: : : : {fixed('minus')}
dostateczny: : : : {fixed('mniej')}
dostateczny: : : : {fixed('plus')}
dostateczny: : : : {preplexnp(na,loc,pl,'szyna',natr)}
dostateczny: : : : {prepnp(dla,gen); prepnp(do,gen); prepncp(dla,gen,żeby); prepncp(do,gen,żeby)}
dostateczny: : : : {prepnp(na,acc); prepncp(na,acc,żeby)}
dostawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostawać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dostawać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
dostawać: _: : imperf: subj{np(str)} + {np(gen)}
dostawać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dostawać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dostawać: _: : imperf: subj{np(str)} + {np(part)} + {prepnp(od,gen)}
dostawać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
dostawać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
dostąpić: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)}
dostąpić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dostęp: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,żeby)} + {prepnp(przez,acc)}
dostęp: : : : {possp} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dostępny: : : : {np(dat)} + {xp(locat)} + {xp(perl)}
dostępny: : : : {preplexnp(dla,gen,_,'kieszeń',atr)}
dostępny: : : : {prepnp(dla,gen); xp(locat); xp(perl)}
dostępny: : : : {prepnp(dla,gen)} + {xp(locat)} + {xp(perl)}
dostępny: : : : {prepnp(do,gen)}
dostępować: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że)}
dostępować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dostosować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostosować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
dostosowywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostosowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostosowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
dostrajać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dostrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dostroić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dostroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dostrzec: _: : perf: subj{np(str)} + {cp(jak)}
dostrzec: _: : perf: subj{np(str)} + {cp(żeby2)}
dostrzec: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dostrzegać: _: : imperf: subj{np(str)} + {cp(jak)}
dostrzegać: _: : imperf: subj{np(str)} + {cp(żeby2)}
dostrzegać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzegać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dosyłać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doszkalać: _: : imperf: subj{np(str)} + {advp(misc)} + {refl}
doszkalać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
doszkalać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
doszkalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
doszkalać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',atr)}
doszkalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)}
doszkalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
doszkalać: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',atr)} + {refl}
doszkalać: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)} + {refl}
doszkalać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
doszkolić: _: : perf: subj{np(str)} + {advp(misc)} + {refl}
doszkolić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
doszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
doszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
doszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',atr)}
doszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)}
doszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
doszkolić: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',atr)} + {refl}
doszkolić: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)} + {refl}
doszkolić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
doszlifować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
doszlifować: _: : perf: subj{np(str)} + obj{np(str)}
doszlifowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
doszlifowywać: _: : imperf: subj{np(str)} + obj{np(str)}
doszperać się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
doszperać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
doszperać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
dosztukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dosztukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dosztukować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dosztukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dosztukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dosztukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doszukać się: _: : perf: subj{np(str)} + {cp(int)}
doszukać się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(w,loc); prepncp(w,loc,że)}
doszukać się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
doszukać się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
doszukiwać się: _: : imperf: subj{np(str)} + {cp(int)}
doszukiwać się: _: : imperf: subj{np(str)} + {cp(że)}
doszukiwać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(w,loc); prepncp(w,loc,że)}
doszukiwać się: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
doszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
doszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
doszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
doszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(locat)}
doszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
doszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
doszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
doszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(locat)}
dościgać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dościgać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dościgać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
doścignąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
doścignąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
doścignąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dość: _: : _: {cp(żeby)} + {infp(_)}
dość: _: : _: {np(gen)}
dośrodkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dośrodkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dośrodkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doświadczać: _: : imperf: subj{np(str)} + {cp(int)}
doświadczać: _: : imperf: subj{np(str)} + {cp(że)}
doświadczać: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)} + {np(inst)}
doświadczenie: : : : {adjp(agr); xp(abl)} + {possp}
doświadczenie: : : : {np(gen)} + {possp}
doświadczenie: : : : {possp} + {comprepnp(na temat)}
doświadczenie: : : : {possp} + {comprepnp(w kwestii)}
doświadczenie: : : : {possp} + {comprepnp(w sprawie)}
doświadczenie: : : : {possp} + {cp(że)}
doświadczenie: : : : {possp} + {prepnp(co do,gen)}
doświadczenie: : : : {possp} + {prepnp(nad,inst)}
doświadczenie: : : : {possp} + {prepnp(na,loc)}
doświadczenie: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
doświadczenie: : : : {possp} + {prepnp(w,loc); xp(locat)}
doświadczenie: : : : {possp} + {prepnp(z,gen)}
doświadczenie: : : : {possp} + {prepnp(z,inst)}
doświadczyć: _: : perf: subj{np(str)} + {cp(int)}
doświadczyć: _: : perf: subj{np(str)} + {cp(że)}
doświadczyć: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)} + {np(inst)}
dotańczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dotknąć się: _: : perf: subj{np(str)} + {np(gen)}
dotknąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dotknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dotknąć: _: : perf: subj{np(str)} + obj{np(gen)}
dotknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dotleniać się: _: : imperf: subj{np(str)} + {np(inst)}
dotleniać się: _: : imperf: subj{np(str)} + {xp(locat)}
dotleniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dotleniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dotlenić się: _: : perf: subj{np(str)} + {np(inst)}
dotlenić się: _: : perf: subj{np(str)} + {xp(locat)}
dotlenić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dotlenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dotować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dotować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
dotrwać: _: : perf: subj{np(str)} + {cp(aż)}
dotrwać: _: : perf: subj{np(str)} + {np(gen)}
dotrwać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dotrzeć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
dotrzeć: _: : perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
dotrzeć: _: : perf: subj{np(str)} + {np(part)}
dotrzeć: _: : perf: subj{np(str)} + obj{np(str)}
dotrzeć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dotrzymać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'koło',natr)}
dotrzymać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'pole',natr)}
dotrzymać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'tempo',natr)}
dotrzymać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'towarzystwo',natr)}
dotrzymać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'wierność',natr)}
dotrzymać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {lexnp(gen,sg,'krok',natr)}
dotrzymać: _: : perf: subj{np(str)} + obj{np(gen)}
dotrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dotrzymywać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'koło',natr)}
dotrzymywać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'pole',natr)}
dotrzymywać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'tempo',natr)}
dotrzymywać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'towarzystwo',natr)}
dotrzymywać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'wierność',natr)}
dotrzymywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {lexnp(gen,sg,'krok',natr)}
dotrzymywać: _: : imperf: subj{np(str)} + obj{np(gen)}
dotrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dotyczyć: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
dotykać się: _: : imperf: subj{np(str)} + {np(gen)}
dotykać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dotykać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dotykać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dotykać: _: : imperf: subj{np(str)} + obj{np(str)}
dowartościować: _: : perf: subj{cp(gdy)} + {np(str)}
dowartościować: _: : perf: subj{cp(int)} + {np(str)}
dowartościować: _: : perf: subj{cp(jak)} + {np(str)}
dowartościować: _: : perf: subj{cp(jeśli)} + {np(str)}
dowartościować: _: : perf: subj{cp(kiedy)} + {np(str)}
dowartościować: _: : perf: subj{cp(że)} + {np(str)}
dowartościować: _: : perf: subj{np(str)} + {cp(int)} + {refl}
dowartościować: _: : perf: subj{np(str)} + {cp(że)} + {refl}
dowartościować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
dowartościować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
dowartościować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dowartościowywać: _: : imperf: subj{cp(gdy)} + {np(str)}
dowartościowywać: _: : imperf: subj{cp(int)} + {np(str)}
dowartościowywać: _: : imperf: subj{cp(jak)} + {np(str)}
dowartościowywać: _: : imperf: subj{cp(jeśli)} + {np(str)}
dowartościowywać: _: : imperf: subj{cp(kiedy)} + {np(str)}
dowartościowywać: _: : imperf: subj{cp(że)} + {np(str)}
dowartościowywać: _: : imperf: subj{np(str)} + {cp(int)} + {refl}
dowartościowywać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
dowartościowywać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
dowartościowywać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
dowartościowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dowędrować: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dowędrować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dowiadywać się: _: : imperf: subj{np(str)} + {np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(u,gen); prepnp(z,gen)}
dowiadywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,loc)} + {prepnp(od,gen)}
dowiadywać się: _: : imperf: subj{np(str)} + {or}
dowiadywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(u,gen)}
dowiedzieć się: _: : perf: subj{np(str)} + {np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(u,gen); prepnp(z,gen)}
dowiedzieć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,loc)} + {prepnp(od,gen)}
dowiedzieć się: _: : perf: subj{np(str)} + {or}
dowiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(u,gen)}
dowierzać: _: : imperf: subj{np(str)} + {cp(żeby2)}
dowierzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dowierzać: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby2)}
dowieść: _: : perf: subj{np(str); ncp(str,że)} + {cp(że)}
dowieść: _: : perf: subj{np(str); ncp(str,że)} + obj{np(gen); ncp(gen,że)} + {np(dat)}
dowieść: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
dowieść: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,że)} + {np(dat)} + {np(inst)}
dowieźć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowieźć: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
dowlec się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowlec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowlekać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowodzić: _: : imperf: subj{np(str); ncp(str,że)} + {cp(że)}
dowodzić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(gen); ncp(gen,że)} + {np(dat)}
dowodzić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
dowodzić: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
dowodzić: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,że)} + {np(dat)} + {np(inst)}
dowodzić: _: : imperf: subj{np(str)} + obj{np(inst)}
dowozić: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowozić: _: : imperf: subj{np(str)} + obj{np(part)} + {np(inst)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
dowód: : : : {np(gen); ncp(gen,że)} + {possp}
dowód: : : : {possp} + {comprepnp(na rzecz)}
dowód: : : : {possp} + {comprepnp(na temat)}
dowód: : : : {possp} + {comprepnp(w kwestii)}
dowód: : : : {possp} + {comprepnp(w sprawie)}
dowód: : : : {possp} + {cp(int); cp(że)}
dowód: : : : {possp} + {cp(jakoby)}
dowód: : : : {possp} + {cp(żeby)}
dowód: : : : {possp} + {prepnp(co do,gen)}
dowód: : : : {possp} + {prepnp(dla,gen)}
dowód: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,jakoby); prepncp(na,acc,że); prepncp(na,acc,żeby)}
dowód: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,że)}
dowód: : : : {possp} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby); prepncp(za,inst,że); prepncp(za,inst,żeby)}
doziębić się: _: : perf: subj{np(str)}
doznać: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)}
doznawać: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)}
dozorować: _: : imperf: subj{np(str)} + {cp(int)}
dozorować: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,int)}
dozorować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
dozować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dożyć: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dożyć: _: : perf: subj{np(str)} + {np(str)}
dożyć: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dożywać: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dożywać: _: : imperf: subj{np(str)} + {np(str)}
dożywać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dożywiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
dożywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dożywić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
dożywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dramatyzować: _: : imperf: subj{np(str)} + {cp(że)}
dramatyzować: _: : imperf: subj{np(str)} + obj{np(str)}
dramatyzować: _: : imperf: subj{np(str)} + {or}
drapać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
drapać: _: : imperf: {np(str)} + {prepnp(w,acc)}
drapać: _: : imperf: {np(str)} + {prepnp(w,loc)}
drapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
drapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
drapać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
drapać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
drapać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
drapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
drapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
drapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
drapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
drapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
drapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
drapnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
drapnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
drapnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
drapnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
drapnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
drapnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
drapować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
drapować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
drapować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
drapować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
drapować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
drapować: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
drapować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
drażnić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
drażnić: _: : imperf: subj{cp(gdy)} + {np(str)}
drażnić: _: : imperf: subj{cp(jak)} + {np(str)}
drażnić: _: : imperf: subj{cp(jeśli)} + {np(str)}
drażnić: _: : imperf: subj{cp(kiedy)} + {np(str)}
drażnić: _: : imperf: subj{cp(że)} + {np(str)}
drażnić: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
drażnić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
drążyć: _: : imperf: subj{np(str)} + {cp(int)}
drążyć: _: : imperf: subj{np(str)} + {cp(że)}
drążyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
drążyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
drenować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
dreptać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
dreptać: _: : imperf: subj{np(str)} + {np(inst)}
dreptać: _: : imperf: subj{np(str)} + {prepnp(koło,gen); prepncp(koło,gen,żeby)}
dreptać: _: : imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,żeby)}
dreptać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
dreptać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dreptać: _: : imperf: subj{np(str)} + {xp(locat)}
dręczyć: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
dręczyć: _: : imperf: subj{np(str)} + {ncp(inst,że)} + {refl}
dręczyć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
dręczyć: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
dręczyć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
dręczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
drgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
drgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
drgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drgać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
drgać: _: : imperf: subj{np(str)} + {np(inst)}
drgnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
drgnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
drgnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drgnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
drgnąć: _: : perf: subj{np(str)} + {np(inst)}
drobić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
drobić: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
drobić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
drobić: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
drobić: _: : imperf: subj{np(str)} + {xp(perl)}
drogi: : : : {np(dat)}
drogi: : : : {prepnp(dla,gen); prepnp(w,loc)}
drożeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
drugi: : : : {prepnp(na,acc); prepnp(w,loc); xp(locat)}
drugi: : : : {prepnp(od,gen)}
drugi: : : : {prepnp(po,loc)}
drugi: : : : {prepnp(z,gen)}
drugi: : pred: : {cp(że)}
drukować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
drukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
drukować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
druzgotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
drwić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
drwić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
drwić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
drzeć się: _: : imperf: subj{np(str)} + {prepncp(o,acc,że)}
drzeć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); cp(żeby)}
drzeć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
drzeć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
drzeć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
drzeć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)} + {or}
drzeć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
drzeć się: _: : imperf: subj{np(str)} + {xp(adl)}
drzeć: _: : imperf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'włos',natr)} + {preplexnp(z,gen,sg,'głowa',natr)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {prepncp(o,acc,że)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {or}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {or}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(przeciw,dat)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
drzeć: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
drzeć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
drzeć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
drzeć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(str,pl,'kot',natr)}
drzeć: _: : imperf: subj{np(str)} + {xp(adl)}
drzemać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
drzemać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(u,gen)}
drzemać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
drzemać: _: : imperf: subj{np(str)} + {xp(locat)}
drzwi: : : : {np(gen)} + {possp}
drzwi: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,żeby)}
drzwi: : : : {possp} + {prepnp(na,acc)}
drzwi: : : : {possp} + {prepnp(od,gen)}
drżeć: _: : imperf: subj{np(str)} + {cp(czy)}
drżeć: _: : imperf: subj{np(str)} + {cp(że)}
drżeć: _: : imperf: subj{np(str)} + {cp(żeby)}
drżeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
drżeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drżeć: _: : imperf: subj{np(str)} + {or}
drżeć: _: : imperf: subj{np(str)} + {preplexnp(w,loc,pl,'posada',natr)}
drżeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
drżeć: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
drżeć: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
drżeć: _: : imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
dudnić: _: : imperf: {np(dat)} + {xp(locat)}
dudnić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dudnić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
dudnić: _: : imperf: subj{np(str)} + {np(inst)} + {or}
dudnić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
dudnić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dudnić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dudnić: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dudnić: _: : imperf: subj{or} + {np(dat)} + {xp(locat)}
dukać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
dukać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
dukać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
dukać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
dukać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
dukać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
duma: : : : {possp} + {cp(że)}
duma: : : : {possp} + {prepnp(z,gen); comprepnp(z powodu); prepncp(z,gen,int); prepncp(z,gen,że)}
dumać: _: : imperf: subj{np(str)} + {cp(int)}
dumać: _: : imperf: subj{np(str)} + {cp(że)}
dumać: _: : imperf: subj{np(str)} + {or}
dumać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
dumny: : : : {cp(że)}
dumny: : : : {np(inst)}
dumny: : : : {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
dusić się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
dusić się: _: : imperf: subj{np(str)} + {np(inst)}
dusić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dusić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
dusić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
dusić się: _: : imperf: subj{np(str)} + {xp(locat)}
dusić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dusić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
duszać: _: : imperf: subj{np(str)} + {np(inst)}
dwoić się: _: : imperf: subj{np(str)}
dwoić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {preplexnp(przed,inst,pl,'oko',natr)}
dwoić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
dwoić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {preplexnp(przed,inst,pl,'oko',natr)}
dwoić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
dwoić: _: : imperf: subj{np(str)} + obj{np(str)}
dybać: _: : imperf: subj{np(str)} + {cp(żeby)}
dybać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
dygotać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
dygotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
dygotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
dyktować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
dyktować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dyktować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
dyktować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
dyktować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
dymić się: _: : imperf: subj{E} + {np(dat)} + {xp(abl)}
dymić się: _: : imperf: subj{E} + {xp(locat)}
dymić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
dymić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dymić się: _: : imperf: subj{np(str)} + {xp(locat)}
dymić: _: : imperf: subj{E} + {np(dat)} + {xp(abl)}
dymić: _: : imperf: subj{E} + {xp(locat)}
dymić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
dymić: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
dymić: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dymić: _: : imperf: subj{np(str)} + {xp(locat)}
dymisjonować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dymisjonować: _: : _: subj{np(str)} + {prepnp(z,gen)} + {refl}
dynamizować się: _: : imperf: subj{np(str)} + {np(dat)}
dynamizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dyrygować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
dyrygować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
dyrygować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int)}
dyrygować: _: : imperf: subj{np(str)} + {np(inst)} + {or}
dyscyplinować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
dyscyplinować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
dyscyplinować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dyscyplinować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dyskryminować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
dyskryminować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dyskusyjny: : : : {prepnp(dla,gen)}
dyskusyjny: : pred: : {prepnp(dla,gen)} + {cp(int)}
dyskusyjny: : pred: : {prepnp(dla,gen)} + {cp(że)}
dyskusyjny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
dyskutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dyskutować: _: : imperf: subj{np(str)} + {or}
dyskutować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); comprepnp(na temat); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
dyskutować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
dyskutować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
dyskutować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
dyskwalifikować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
dyskwalifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dysponować: _: : imperf: subj{np(str)} + {np(inst)}
dysponować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dysponować: _: : imperf: subj{np(str)} + {or}
dystansować się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dystansować się: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
dystansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dystansować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dystansować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dystrybuować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dystrybuować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
dyszeć: _: : imperf: subj{np(str)} + {fixed('ledwie')}
dyszeć: _: : imperf: subj{np(str)} + {fixed('ledwo')}
dyszeć: _: : imperf: subj{np(str)} + {np(inst)}
dyżurować: _: : imperf: subj{np(str)} + {xp(locat)}
dziać się: _: : imperf: controller{np(dat)} + controllee{xp(mod)}
dziać się: _: : imperf: subj{np(str)} + {np(dat)}
dziać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
dziać się: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
dziadować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
dziadować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {xp(locat)}
działać: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
działać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
działać: _: : imperf: subj{np(str)} + {xp(locat)}
dziczeć: _: : imperf: subj{np(str)}
dziedziczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
dzielić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
dzielić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dzielić się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
dzielić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
dzielić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dzielić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
dzielić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
dzielić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
dzielić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dzień: : : : {cp(gdy)}
dzień: : : : {cp(kiedy)}
dzień: : : : {np(gen)}
dzień: : : : {possp} + {fixed('ciche')}
dzierżawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
dzierżawić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
dzierżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dziesiątkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dziękować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dziękować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dziobać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
dziobać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
dziobać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
dziobać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
dziobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
dziobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dziobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dziobać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dziobnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
dziobnąć: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)}
dziobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dziobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dziura: : : : {fixed('czarna')}
dziura: : : : {possp} + {prepnp(po,loc)} + {prepnp(w,loc)}
dziura: : : : {possp} + {xp(locat)}
dziurawić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
dziurawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dziwić się: _: : imperf: subj{np(str)} + {np(dat); cp(int); cp(że); ncp(dat,int); ncp(dat,że)}
dziwić się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dziwić się: _: : imperf: subj{np(str)} + {or}
dziwić: _: : imperf: subj{cp(int)} + {np(str)}
dziwić: _: : imperf: subj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {np(str)}
dziwić: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
dziwny: : : : {prepnp(w,loc); prepncp(w,loc,że)}
dziwny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
dziwny: : pred: : {prepnp(dla,gen)} + {cp(int)}
dziwny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
dziwny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
dziwny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
dziwny: : pred: : {prepnp(dla,gen)} + {cp(że)}
dziwny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
dzwonić: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
dzwonić: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
dzwonić: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
dzwonić: _: : imperf: subj{np(str)} + {cp(int); cp(że); cp(żeby)} + {xp(abl)} + {xp(adl)}
dzwonić: _: : imperf: subj{np(str)} + {np(dat)}
dzwonić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
dzwonić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
dzwonić: _: : imperf: subj{np(str)} + {np(inst)}
dzwonić: _: : imperf: subj{np(str)} + {preplexnp(do,gen,pl,'drzwi',atr)}
dzwonić: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'trwoga',natr)}
dzwonić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dzwonić: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)}
dzwonić: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)}
dzwonić: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
dzwonić: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {xp(abl)} + {xp(adl)}
dźgać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
dźgać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
dźgać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
dźgać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dźgać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
dźgnąć: _: : perf: {np(str)}
dźgnąć: _: : perf: subj{cp(że)} + {np(str)}
dźgnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
dźgnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
dźgnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
dźgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dźgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
dźwigać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
dźwigać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
dźwigać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
dźwigać się: _: : imperf: subj{np(str)} + {xp(abl)}
dźwigać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dźwigać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
dźwigać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dźwigać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dźwigać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dźwigać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dźwignąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
dźwignąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
dźwignąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
dźwignąć się: _: : perf: subj{np(str)} + {xp(abl)}
dźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
edukować się: _: : imperf: subj{np(str)} + {advp(misc)}
edukować się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
edukować się: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
edukować się: _: : imperf: subj{np(str)} + {cp(int)}
edukować się: _: : imperf: subj{np(str)} + {cp(że)}
edukować się: _: : imperf: subj{np(str)} + {cp(żeby)}
edukować się: _: : imperf: subj{np(str)} + {np(inst)}
edukować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
edukować się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
edukować się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
edukować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
edukować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
edukować się: _: : imperf: subj{np(str)} + {xp(locat)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
edukować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
edytować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
edytować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
egzamin: : : : {possp} + {comprepnp(na temat)}
egzamin: : : : {possp} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(z,gen)}
egzamin: : : : {possp} + {prepnp(o,loc)}
egzamin: : : : {possp} + {prepnp(po,loc)} + {prepnp(z,gen)}
egzaminować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
egzaminować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
egzaminować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
egzekwować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
ekscytować się: _: : imperf: subj{np(str)} + {cp(int)}
ekscytować się: _: : imperf: subj{np(str)} + {cp(że)}
ekscytować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ekscytować się: _: : imperf: subj{np(str)} + {or}
ekscytować: _: : imperf: subj{cp(int)} + {np(str)}
ekscytować: _: : imperf: subj{cp(że)} + {np(str)}
ekscytować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
ekscytować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
eksmitować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
eksperyment: : : : {np(inst)} + {possp}
eksperyment: : : : {possp} + {comprepnp(na temat)}
eksperyment: : : : {possp} + {comprepnp(w sprawie)}
eksperyment: : : : {possp} + {prepnp(co do,gen)}
eksperyment: : : : {possp} + {prepnp(nad,inst)}
eksperyment: : : : {possp} + {prepnp(na,loc)}
eksperyment: : : : {possp} + {prepnp(o,loc)}
eksperyment: : : : {possp} + {prepnp(z,gen)}
eksperyment: : : : {possp} + {prepnp(z,inst)}
eksperymentować: _: : imperf: subj{np(str)} + {np(inst)}
eksperymentować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
eksperymentować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
eksploatować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
eksploatować: _: : imperf: subj{np(str)} + {refl}
eksplodować: _: : _: subj{np(str)} + {np(inst)}
eksplodować: _: : _: subj{np(str)} + obj{np(str)}
eksponować się: _: : imperf: subj{np(str)}
eksponować: _: : imperf: subj{np(str)} + {cp(że)}
eksponować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
eksportować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ekwipować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ekwipować: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
elektryzować się: _: : imperf: subj{np(str)} + {np(inst)}
elektryzować: _: : imperf: subj{cp(int)} + {np(str)}
elektryzować: _: : imperf: subj{cp(że)} + {np(str)}
elektryzować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
elektryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
eliminować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
emaliować: _: : imperf: subj{np(str)} + obj{np(str)}
emanować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
emanować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
emanować: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
emanować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
emerytować: _: : _: subj{np(str)} + obj{np(str)}
emerytować: _: : _: subj{np(str)} + {refl}
emigrować: _: : _: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
emisja: : : : {np(gen)} + {possp} + {xp(abl)} + {xp(adl)}
emisja: : : : {np(gen)} + {possp} + {xp(locat)}
emitować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
emocjonować się: _: : imperf: subj{np(str)} + {cp(int)}
emocjonować się: _: : imperf: subj{np(str)} + {cp(że)}
emocjonować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
emocjonować się: _: : imperf: subj{np(str)} + {or}
emocjonować: _: : imperf: subj{cp(gdy)} + {np(str)}
emocjonować: _: : imperf: subj{cp(int)} + {np(str)}
emocjonować: _: : imperf: subj{cp(jak)} + {np(str)}
emocjonować: _: : imperf: subj{cp(jeśli)} + {np(str)}
emocjonować: _: : imperf: subj{cp(kiedy)} + {np(str)}
emocjonować: _: : imperf: subj{cp(że)} + {np(str)}
emocjonować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
epatować: _: : imperf: subj{np(str)} + {cp(int)} + {refl}
epatować: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
epatować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
epatować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
epatować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
epatować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
epoka: : : : {cp(gdy)}
epoka: : : : {cp(kiedy)}
epoka: : : : {np(gen)} + {prepnp(w,loc)}
epoka: : : : {np(gen)} + {xp(locat)}
epoka: : : : {possp} + {xp(locat)}
eskortować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
estetyzować: _: : imperf: subj{np(str)} + obj{np(str)}
ewakuować się: _: : _: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ewakuować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ewidencjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ewidentny: : : : {prepnp(dla,gen)}
ewidentny: : pred: : {cp(że)}
fajny: : : : {prepnp(dla,gen)}
fajny: : : : {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
fajny: : : : {prepnp(w,loc)}
fajny: : pred: : {cp(gdy)}
fajny: : pred: : {cp(jak); cp(że)}
fajny: : pred: : {cp(jeśli)}
fajny: : pred: : {cp(kiedy)}
falować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
falować: _: : imperf: subj{np(str)} + obj{np(str)}
fałszować: _: : imperf: subj{np(str)} + {cp(że)}
fałszować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
fantastyczny: : : : {prepnp(dla,gen); prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
fantastyczny: : : : {prepnp(w,loc); prepncp(w,loc,że)}
fantastyczny: : : : {xp(locat); xp(temp)}
fantastyczny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
fantastyczny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
fantastyczny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
fantastyczny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
fantastyczny: : pred: : {prepnp(dla,gen)} + {cp(że)}
fantastyczny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
farbować się: _: : imperf: subj{np(str)} + {advp(misc)}
farbować się: _: : imperf: subj{np(str)} + {np(inst)}
farbować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
farbować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
farbować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
farbować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
fascynować się: _: : imperf: subj{np(str)} + {cp(int)}
fascynować się: _: : imperf: subj{np(str)} + {cp(że)}
fascynować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
fascynować: _: : imperf: subj{cp(int)} + {np(str)}
fascynować: _: : imperf: subj{cp(że)} + {np(str)}
fascynować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
fascynować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
faszerować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
faszerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
fatalny: : : : {prepnp(dla,gen)}
fatalny: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
fatalny: : : : {prepnp(na,acc); prepncp(na,acc,żeby)}
fatalny: : : : {prepnp(w,loc); prepncp(w,loc,żeby)}
fatalny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
fatalny: : pred: : {prepnp(dla,gen)} + {cp(int)}
fatalny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
fatalny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
fatalny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
fatalny: : pred: : {prepnp(dla,gen)} + {cp(że)}
fatygować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
fatygować się: _: : imperf: subj{np(str)} + {cp(żeby)}
fatygować się: _: : imperf: subj{np(str)} + {np(inst)}
fatygować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
fatygować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
fatygować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
fatygować się: _: : imperf: subj{np(str)} + {xp(adl)}
fatygować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
fatygować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
fatygować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
fatygować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
fatygować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
fatygować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
faulować: _: : imperf: subj{np(str)} + obj{np(str)}
faworyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(inst,sg,'koszt',ratr)}
fechtować się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
fechtować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
fedrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
fedrować: _: : imperf: subj{np(str)} + {xp(locat)}
fermentować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
fermentować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
fermentować: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
fermentować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
fermentować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
ferować: _: : imperf: subj{np(str)} + obj{np(str)}
figurować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {xp(locat)}
figurować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(locat)}
fikać: _: : imperf: subj{np(str)} + {np(inst)}
fikać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
fikać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
fikać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
fiknąć: _: : perf: subj{np(str)} + {np(inst)}
fiknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
fiknąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
fiknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
filmować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
filmować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(inst)}
filmować: _: : imperf: subj{np(str)} + obj{cp(jak)} + {np(inst)}
filmować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak)} + {np(inst)}
finalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
finansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
finansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
firmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
flirtować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
folgować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
folgować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
formalizować się: _: : imperf: subj{np(str)}
formalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
formatować się: _: : imperf: subj{np(str)} + {np(dat)}
formatować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)}
formatować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
formatować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
formować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
formować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
formować się: _: : imperf: subj{np(str)} + {xp(locat)}
formować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
formować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
formować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
formułować: _: : imperf: subj{np(str)} + controller{ncp(str,że)} + controllee{prepnp(jako,str)}
formułować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
formułować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
forsować się: _: : imperf: subj{np(str)} + {np(inst)}
forsować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
forsować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
forsować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
forsować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
fosforyzować: _: : imperf: subj{np(str)} + {np(inst)}
fotografować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
fotografować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
frezować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
frezować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
frustrować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
frustrować się: _: : imperf: subj{np(str)} + {cp(int)}
frustrować się: _: : imperf: subj{np(str)} + {cp(że)}
frustrować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
frustrować się: _: : imperf: subj{np(str)} + {or}
frustrować: _: : imperf: subj{cp(gdy)} + {np(str)}
frustrować: _: : imperf: subj{cp(int)} + {np(str)}
frustrować: _: : imperf: subj{cp(jak)} + {np(str)}
frustrować: _: : imperf: subj{cp(jeśli)} + {np(str)}
frustrować: _: : imperf: subj{cp(kiedy)} + {np(str)}
frustrować: _: : imperf: subj{cp(że)} + {np(str)}
frustrować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
frustrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
fruwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
fruwać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
fundować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
fundować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
funkcjonować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
funkcjonować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
funkcjonować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
gadać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
gadać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
gadać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
gadać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
gadać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
gadać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
gadać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
gadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
gadać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
gadać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
gadać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
gadać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
gadać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
galopować: _: : imperf: subj{np(str)} + {np(inst)}
galopować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ganić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
ganić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
ganić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ganić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ganić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
gapić się: _: : imperf: subj{np(str)} + {cp(jak)}
gapić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
gapić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
gapić się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
garażować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gardzić: _: : imperf: subj{np(str)} + {np(inst)}
garnąć się: _: : imperf: subj{np(str)} + {cp(żeby)}
garnąć się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
garnąć się: _: : imperf: subj{np(str)} + {xp(adl)}
garnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
garnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
gasić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
gasić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
gasić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
gasić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'zarodek',natr)}
gasnąć: _: : imperf: subj{np(str)} + {np(dat)}
gawędzić: _: : imperf: subj{np(str)} + {or}
gawędzić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
gawędzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
gazować: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(adl)} + {xp(perl)}
gazować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gazyfikować: _: : imperf: subj{np(str)} + obj{np(str)}
gderać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
gderać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
gderać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
gderać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
gderać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
gderać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
gderać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
gdybać: _: : imperf: subj{np(str)} + {cp(int)}
gdybać: _: : imperf: subj{np(str)} + {cp(że)}
gdybać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
generować się: _: : imperf: subj{np(str)} + {np(dat)}
generować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
generować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
generować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
generować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
genialny: : : : {prepnp(do,gen)}
genialny: : : : {prepnp(na,acc)}
genialny: : : : {prepnp(w,loc)}
genialny: : pred: : {cp(gdy)}
genialny: : pred: : {cp(jak)}
genialny: : pred: : {cp(jeśli)}
genialny: : pred: : {cp(kiedy)}
genialny: : pred: : {cp(że)}
gest: : : : {np(gen)} + {possp} + {comprepnp(na rzecz)}
gest: : : : {np(gen)} + {possp} + {prepnp(wobec,gen)}
gest: : : : {np(gen)} + {possp} + {prepnp(względem,gen); comprepnp(w stosunku do)}
gest: : : : {possp} + {cp(jakby)}
gest: : : : {possp} + {cp(że); cp(żeby)}
gest: : : : {possp} + {or}
gestykulować: _: : imperf: subj{np(str)} + {cp(że)}
gestykulować: _: : imperf: subj{np(str)} + {np(inst)}
gęstnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
gęstnieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
giąć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
giąć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
giąć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
giąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
giąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
giąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
giąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
gimnastykować się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
gimnastykować się: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,żeby)}
gimnastykować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
gimnastykować: _: : imperf: subj{np(str)} + obj{np(str)}
ginąć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,pl,'oko',natr)}
ginąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
ginąć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
ginąć: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
ginąć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
ginąć: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
ginąć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
ginąć: _: : imperf: subj{np(str)} + {xp(locat)}
gloryfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
gładki: : : : {prepnp(w,loc)}
gładzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
gładzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gładzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
głaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
głaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
głaskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
głaskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
głaskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
głasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
głasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
głasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
głasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
głasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
głębić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
głodny: : : : {np(gen); ncp(gen,żeby)}
głodować: _: : imperf: subj{np(str)}
głodzić: _: : imperf: subj{np(str)} + obj{np(str)}
głodzić: _: : imperf: subj{np(str)} + {refl}
głos: : : : {cp(żeby)}
głos: : : : {np(gen)} + {possp}
głos: : : : {possp} + {comprepnp(w kwestii)}
głos: : : : {possp} + {comprepnp(w sprawie)}
głos: : : : {possp} + {or}
głos: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
głos: : : : {possp} + {prepnp(o,loc); comprepnp(na temat); cp(że); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
głos: : : : {possp} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby); prepncp(za,inst,że); prepncp(za,inst,żeby)}
głosić: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
głosić: _: : imperf: subj{np(str)} + {or}
głosić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
głosować: _: : imperf: subj{np(str)} + {cp(żeby)}
głosować: _: : imperf: subj{np(str)} + obj{np(str)}
głosować: _: : imperf: subj{np(str)} + {or}
głosować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
głosować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
głosować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)}
głośny: : : : {prepnp(z,gen); prepncp(z,gen,że)}
głowić się: _: : imperf: subj{np(str)} + {cp(int)}
głowić się: _: : imperf: subj{np(str)} + {or}
głowić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
główkować: _: : imperf: subj{np(str)} + {cp(int)}
główkować: _: : imperf: subj{np(str)} + {or}
główkować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
główkować: _: : imperf: subj{np(str)} + {xp(adl)}
głuchnąć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
głuchy: : : : {prepnp(na,acc); prepncp(na,acc,że)}
głuchy: : : : {prepnp(od,gen)}
głupieć: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
głupieć: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
głupieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
głupieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
gmatwać się: _: : imperf: subj{np(str)} + {np(dat)}
gmatwać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
gmatwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
gnać: _: : imperf: {np(str)} + {prepnp(do,gen)}
gnać: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
gnać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
gnać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
gnać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
gnębić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
gnębić: _: : imperf: subj{cp(int)} + {np(str)}
gnębić: _: : imperf: subj{cp(że)} + {np(str)}
gnębić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
gnębić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gnębić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
gniazdować: _: : imperf: subj{np(str)} + {xp(locat)}
gnić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
gnić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
gnić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
gnić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
gnić: _: : imperf: subj{np(str)} + {xp(locat)}
gnieść się: _: : imperf: subj{np(str)} + {xp(locat)}
gnieść: _: : imperf: {np(str)} + {xp(locat)}
gnieść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gnieść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
gnieść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
gnieść: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gniewać się: _: : imperf: subj{np(str)} + {or}
gniewać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
gniewać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
gniewać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
gniewać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
gniewać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
gniewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
gniewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
gniewać: _: : imperf: subj{cp(że)} + {np(str)}
gniewać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
gniewny: : : : {prepnp(na,acc)} + {comprepnp(z powodu)}
gniewny: : : : {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
gnieździć się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
gnieździć się: _: : imperf: subj{np(str)} + {xp(locat)}
godny: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)}
godny: : pred: : {cp(gdy)}
godny: : pred: : {cp(jak)}
godny: : pred: : {cp(jeśli)}
godny: : pred: : {cp(kiedy)}
godny: : pred: : {cp(że)}
godny: : pred: : {cp(żeby)}
godzić się: _: : imperf: {np(dat)} + {advp(pron)}
godzić się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
godzić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
godzić się: _: : imperf: subj{cp(żeby)} + {np(dat)}
godzić się: _: : imperf: subj{np(str)} + {cp(że)}
godzić się: _: : imperf: subj{np(str)} + {cp(żeby)}
godzić się: _: : imperf: subj{np(str)} + {or}
godzić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
godzić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
godzić się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
godzić się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że); prepncp(z,inst,żeby)}
godzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
godzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
godzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
godzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
godzić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
godzina: : : : {fixed('zero')}
godzina: : : : {np(gen)} + {possp}
godzina: : : : {xp(temp)}
goić się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
goić się: _: : imperf: subj{np(str)} + controller{prepnp(na,loc)} + controllee{xp(mod)}
goić: _: : imperf: subj{np(str)} + {np(str)}
golić: _: : imperf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
golić: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
golić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
golić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
golić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
golić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
gonić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
gonić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
gonić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
gonić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
gonić: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
goreć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
goreć: _: : imperf: {xp(locat)}
gorliwy: : : : {prepnp(do,gen)}
gorliwy: : : : {prepnp(o,acc)}
gorliwy: : : : {prepnp(w,loc)}
gorzeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
gorzeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
gorzeć: _: : imperf: subj{np(str)} + {xp(locat)}
gospodarować: _: : imperf: subj{np(str)} + {np(inst)}
gospodarować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
gospodarować: _: : imperf: subj{np(str)} + {xp(locat)}
gościć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gościć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
gościć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gotować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
gotować się: _: : imperf: subj{np(str)} + {cp(żeby)}
gotować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
gotować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
gotować się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
gotować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
gotować się: _: : imperf: subj{np(str)} + {xp(locat)}
gotować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
gotować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
gotowy: : : : {preplexnp(na,acc,sg,'skinienie',ratr)}
gotowy: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
gotowy: : : : {prepnp(na,acc); cp(żeby); prepncp(na,acc,że); prepncp(na,acc,żeby)}
górować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(nad,inst)}
gra: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)}
gra: : : : {adjp(agr); prepnp(na,acc); prepnp(na,loc)} + {possp} + {prepnp(dla,gen)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
gra: : : : {np(inst)} + {adjp(agr)} + {possp} + {prepnp(na,loc); prepnp(w,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(w,loc)} + {prepnp(z,inst)} + {xp(locat)}
gra: : : : {possp} + {comprepnp(na rzecz)}
gra: : : : {possp} + {cp(że)}
gra: : : : {possp} + {prepnp(z,gen)}
gra: : : : {prepnp(na,acc); prepncp(na,acc,że)}
grabić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {lexnp(dat,_,'siebie',natr)}
grabić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
grabić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(pod,acc,_,'siebie',natr)}
grabić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
grabić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
grabić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
grabić: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
grać: _: : imperf: {np(dat)} + {prepnp(w,loc)}
grać: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
grać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
grać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
grać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
grać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(u,gen); prepnp(w,loc); xp(locat)}
grać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
grać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(za,acc)}
grać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
grać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {prepnp(w,acc)} + {prepnp(z,inst)}
graniczyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
grasować: _: : imperf: subj{np(str)} + {xp(locat)}
gratulować: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen); cp(że); ncp(gen,że)}
gromadzić się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
gromadzić się: _: : imperf: subj{np(str)} + {xp(locat)}
gromadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
gromadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gromić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
gromić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {or}
grozić: _: : imperf: subj{cp(że)} + {np(dat)}
grozić: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
grozić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); cp(że); ncp(inst,że)}
grozić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
grozić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
gruchać: _: : imperf: subj{np(str)} + {np(inst)}
gruchać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
gruchać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
gruchać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
gruchać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
gruchać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
gruchać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
gruchnąć: _: : perf: subj{cp(że)} + {xp(locat)}
gruchnąć: _: : perf: subj{np(str)} + {cp(że)}
gruchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
gruchnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
gruchnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
gruchnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
gruchnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
gruchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
gruchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
gruchnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
gruchnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
gruchnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
gruchnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
gruchnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
gruchnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
gruchnąć: _: : perf: subj{or} + {xp(abl)}
gruchnąć: _: : perf: subj{or} + {xp(locat)}
grunt: : : : {cp(że)}
grunt: : : : {cp(żeby)}
grunt: : : : {np(gen)} + {possp}
grunt: : : : {possp} + {prepnp(pod,acc)}
grunt: : : : {prepnp(dla,gen)}
grunt: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
grywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
grywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
grywać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {prepnp(w,acc)} + {prepnp(z,inst)}
gryźć się: _: : imperf: subj{np(str)} + {cp(int)}
gryźć się: _: : imperf: subj{np(str)} + {cp(że)}
gryźć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
gryźć się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
gryźć: _: : imperf: subj{cp(int)} + {np(str)}
gryźć: _: : imperf: subj{cp(że)} + {np(str)}
gryźć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
gryźć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gryźć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
gryźć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
gryźć: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
gryźć: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
grzać się: _: : imperf: subj{np(str)} + {np(inst)}
grzać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
grzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
grzać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
grzebać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
grzebać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
grzebać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
grzebać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
grzebać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
grzebać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
grzech: : : : {np(gen)} + {possp}
grzech: : : : {np(gen)} + {possp} + {comprepnp(w stosunku do)}
grzech: : : : {np(gen)} + {possp} + {prepnp(przeciw,dat)}
grzech: : : : {np(gen)} + {possp} + {prepnp(wobec,gen)}
grzech: : : : {np(gen)} + {possp} + {prepnp(względem,gen)}
grzech: : : : {possp} + {cp(że)}
grzech: : : : {possp} + {cp(żeby)}
grzechotać: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
grzechotać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
grzechotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
grzeczny: : : : {comprepnp(w stosunku do)}
grzeczny: : : : {prepnp(dla,gen)}
grzeczny: : : : {prepnp(wobec,gen)}
grzeczny: : : : {prepnp(względem,gen)}
grzeszyć: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
grzeszyć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
grzeszyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
grzęznąć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
grzęznąć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
grzęznąć: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
grzmieć: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
grzmieć: _: : imperf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
grzmieć: _: : imperf: subj{E}
grzmieć: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
grzmieć: _: : imperf: subj{np(str)} + {cp(żeby)}
grzmieć: _: : imperf: subj{np(str)} + {np(inst)}
grzmieć: _: : imperf: subj{np(str)} + {or}
grzmieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
grzmieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
grzmieć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
grzmieć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
grzmocić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
grzmocić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
grzmocić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
grzmocić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
grzmocić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
grzmocić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
grzmocić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
grzmocić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
grzmocić: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,gen)}
grzmotnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
grzmotnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
grzmotnąć się: _: : perf: subj{np(str)} + {xp(adl)}
grzmotnąć: _: : perf: subj{E}
grzmotnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
grzmotnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
grzmotnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
grzmotnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
grzmotnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
grzmotnąć: _: : perf: subj{np(str)} + {xp(adl)}
gubić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
gubić się: _: : imperf: subj{np(str)} + {np(inst)}
gubić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
gubić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
gubić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gubić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'oko',natr)}
gubić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gumować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gustować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
gwałcić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
gwałcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gwarancja: : : : {adjp(agr); prepnp(na,acc)} + {possp} + {prepnp(na,acc); prepncp(na,acc,że)}
gwarancja: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)} + {possp} + {prepnp(dla,gen)}
gwarancja: : : : {possp} + {prepnp(dla,gen)} + {cp(że)}
gwarancja: : : : {possp} + {prepnp(dla,gen)} + {cp(żeby)}
gwarancja: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
gwarantować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
gwarantować: _: : imperf: subj{np(str)} + {or}
gwarzyć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
gwarzyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
gwarzyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
gwizdać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
gwizdać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
gwizdać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
gwizdać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
gwizdnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
gwizdnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
gwizdnąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
gwizdnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
gwizdnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
gwizdnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
gwizdnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
gwizdnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
gwizdnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
haftować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
haftować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
haftować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
hamować: _: : imperf: subj{np(str)} + {cp(żeby)} + {refl}
hamować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
hamować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
hamować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
hamować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
hamować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
hamować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
hamować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
handlować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
haratać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
haratać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
haratać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
haratać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
haratać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
haratać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
haratać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
harcować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
harcować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
harcować: _: : imperf: subj{np(str)} + {xp(locat)}
harmonizować: _: : imperf: subj{np(str)} + {np(inst)}
harmonizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
heblować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
histeryzować: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
histeryzować: _: : imperf: subj{np(str)} + {cp(że)}
histeryzować: _: : imperf: subj{np(str)} + {np(inst)}
histeryzować: _: : imperf: subj{np(str)} + {or}
histeryzować: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
histeryzować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
hodować się: _: : imperf: subj{np(str)} + {advp(misc)}
hodować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
hodować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
hodować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
hodować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
hodować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
hojny: : : : {comprepnp(w stosunku do)}
hojny: : : : {prepnp(dla,gen)} + {prepnp(w,loc)}
hojny: : : : {prepnp(wobec,gen)}
hojny: : : : {prepnp(względem,gen)}
holować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
hołdować: _: : imperf: subj{np(str)} + {np(dat)}
hołdować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
hołubić: _: : imperf: subj{np(str)} + obj{np(str)}
honorować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
honorować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
hospitalizować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
hospitalizować: _: : _: subj{np(str)} + {xp(locat)} + {refl}
huczeć: _: : imperf: {np(dat)} + {xp(locat)}
huczeć: _: : imperf: {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {xp(locat)}
huczeć: _: : imperf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
huczeć: _: : imperf: subj{cp(int)} + {xp(locat)}
huczeć: _: : imperf: subj{cp(że)} + {xp(locat)}
huczeć: _: : imperf: subj{np(str)} + {cp(int)}
huczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
huczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
huczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
huczeć: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
huczeć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
huknąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
huknąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
huknąć: _: : perf: subj{cp(że)} + {xp(locat)}
huknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
huknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
huknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
huknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
huknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
huknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
huknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
huknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
huknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
hulać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
hulać: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
hulać: _: : imperf: subj{np(str)} + {xp(locat)}
hulać: _: : imperf: subj{np(str)} + {xp(perl)}
humanizować się: _: : imperf: subj{np(str)}
humanizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
huśtać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
huśtać: _: : imperf: subj{np(str)} + {np(inst)}
huśtać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
idea: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)} + {possp}
idea: : : : {possp} + {cp(że)}
idea: : : : {possp} + {cp(żeby)}
idea: : : : {possp} + {or}
idea: : : : {possp} + {prepnp(co do,gen)}
idea: : : : {possp} + {prepnp(na,acc)}
idealizować: _: : imperf: subj{np(str)} + obj{np(str)}
identyczny: : : : {np(dat)} + {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)}
identyczny: : : : {prepnp(do,gen)} + {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)}
identyczny: : : : {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)} + {comp(co)}
identyczny: : : : {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)} + {comp(jak)}
identyczny: : : : {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)} + {prepnp(z,inst)}
identyfikować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
identyfikować się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
identyfikować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
identyfikować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
identyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
ignorować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
igrać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
igrać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
iluminować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
iluminować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ilustrować: _: : imperf: subj{np(str)} + {cp(int); cp(że)}
ilustrować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
imać się: _: : imperf: subj{np(str)} + {np(gen)}
imigrować: _: : _: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
immatrykulować się: _: : _: subj{np(str)} + {xp(locat)}
immatrykulować: _: : _: subj{np(str)} + obj{np(str)}
implikować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)}
implikować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
importować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
importować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
impregnować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
impregnować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
impregnować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
impregnować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
imputować: _: : imperf: subj{np(str)} + obj{cp(jakoby)} + {np(dat)}
imputować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
inaugurować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
indywidualizować się: _: : imperf: subj{np(str)}
indywidualizować: _: : imperf: subj{np(str)} + obj{np(str)}
infekować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
informacja: : : : {adjp(agr); prepnp(co do,gen); prepnp(o,loc); comprepnp(na temat); comprepnp(w kwestii); comprepnp(w sprawie); cp(int); cp(jakoby); cp(że); cp(żeby); prepncp(co do,gen,int); prepncp(co do,gen,jakoby); prepncp(co do,gen,że); prepncp(co do,gen,żeby); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby); preplexnp(z,gen,sg,'zakres',atr)} + {possp; xp(abl)} + {prepnp(dla,gen); prepnp(do,gen)}
informacja: : : : {possp} + {or}
informacja: : : : {possp} + {prepnp(z,gen)}
informacja: : : : {prepnp(dla,gen); prepnp(o,loc)}
informacja: : : : {prepnp(od,gen)} + {or}
informować się: _: : imperf: subj{np(str)} + {comprepnp(co do)} + {xp(locat)}
informować się: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {xp(locat)}
informować się: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(locat)}
informować się: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(locat)}
informować się: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
informować się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {xp(locat)}
informować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
informować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
informować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
informować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
informować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jakoby)}
informować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
informować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
ingerować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc); prepncp(w,acc,int)}
inicjatywa: : : : {adjp(agr); comprepnp(na rzecz)} + {possp}
inicjatywa: : : : {np(gen)} + {possp}
inicjatywa: : : : {possp} + {comprepnp(w sprawie)}
inicjatywa: : : : {possp} + {cp(żeby)}
inicjatywa: : : : {possp} + {preplexnp(w,loc,sg,'zakres',atr)}
inicjatywa: : : : {possp} + {prepnp(dla,gen)}
inicjatywa: : : : {possp} + {prepnp(do,gen)}
inicjatywa: : : : {possp} + {prepnp(przeciw,dat)}
inicjować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
inkasować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
inkrustować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
inscenizować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
inspirować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
inspirować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
inspirować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
instalować się: _: : imperf: subj{np(str)} + {xp(locat)}
instalować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
instrumentować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
instruować się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
instruować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
insynuować: _: : imperf: subj{np(str)} + obj{cp(jakoby)} + {np(dat)}
insynuować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
integracja: : : : {np(gen)} + {prepnp(między,inst); prepnp(wśród,gen); prepnp(z,inst)}
integracja: : : : {np(gen)} + {prepnp(przeciw,dat)}
integracja: : : : {np(gen)} + {prepnp(w,acc)} + {prepnp(z,inst)}
integracja: : : : {np(gen)} + {prepnp(wokół,gen)} + {prepnp(z,inst)}
integracja: : : : {np(gen)} + {prepnp(względem,gen)}
integrować się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
integrować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
integrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
integrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
intensyfikować się: _: : imperf: subj{np(str)}
intensyfikować: _: : imperf: subj{np(str)} + obj{np(str)}
interesować się: _: : imperf: subj{np(str)} + {cp(int)}
interesować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
interesować: _: : imperf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(str)}
internować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(locat)}
interpretacja: : : : {np(gen); ncp(gen,int); ncp(gen,że)} + {adjp(agr)} + {possp}
interpretacja: : : : {possp} + {comprepnp(na temat)}
interpretacja: : : : {possp} + {comprepnp(w kwestii)}
interpretacja: : : : {possp} + {comprepnp(w sprawie)}
interpretacja: : : : {possp} + {cp(int)}
interpretacja: : : : {possp} + {cp(jakoby)}
interpretacja: : : : {possp} + {cp(że)}
interpretacja: : : : {possp} + {cp(żeby)}
interpretacja: : : : {possp} + {or}
interpretacja: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
interpretacja: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,że)}
interpretować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(mod)}
interweniować: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {xp(locat)}
interweniować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(locat)}
interweniować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
interweniować: _: : imperf: subj{np(str)} + {np(inst)}
interweniować: _: : imperf: subj{np(str)} + {prepncp(o,acc,żeby)} + {xp(locat)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(u,gen)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {comprepnp(w sprawie)} + {xp(locat)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {comprepnp(na temat)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {or}
interweniować: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepncp(o,acc,żeby)}
interweniować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
intrygować: _: : imperf: subj{cp(int)} + {np(str)}
intrygować: _: : imperf: subj{cp(że)} + {np(str)}
intrygować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
intrygować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
intrygować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
inwentaryzować: _: : imperf: subj{np(str)} + obj{np(str)}
inwestować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ironizować: _: : imperf: subj{np(str)} + {comprepnp(co do)}
ironizować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
ironizować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
ironizować: _: : imperf: subj{np(str)} + {cp(że)}
ironizować: _: : imperf: subj{np(str)} + {or}
ironizować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
irytować się: _: : imperf: subj{np(str)} + {cp(int)}
irytować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
irytować się: _: : imperf: subj{np(str)} + {or}
irytować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
irytować: _: : imperf: subj{cp(gdy)} + {np(str)}
irytować: _: : imperf: subj{cp(int)} + {np(str)}
irytować: _: : imperf: subj{cp(jak)} + {np(str)}
irytować: _: : imperf: subj{cp(jeśli)} + {np(str)}
irytować: _: : imperf: subj{cp(kiedy)} + {np(str)}
irytować: _: : imperf: subj{cp(że)} + {np(str)}
irytować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
irytować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
istnieć: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
istnieć: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
istnieć: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
istotny: : : : {comprepnp(w stosunku do)} + {advp(misc)}
istotny: : : : {prepnp(dla,gen)} + {advp(misc)}
istotny: : : : {xp(locat)}
istotny: : pred: : {prepnp(dla,gen)} + {cp(int)}
istotny: : pred: : {prepnp(dla,gen)} + {cp(że)}
istotny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
iść: _: : imperf: {infp(_)}
iść: _: : imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
iść: _: : imperf: {np(dat)} + {xp(mod)}
iść: _: : imperf: {prepadjp(ku,dat)}
iść: _: : imperf: {prepnp(ku,dat); prepncp(ku,dat,że)}
iść: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
iść: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
iść: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(o,acc,sg,'głowa',natr)}
iść: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(o,acc,sg,'zakład',natr)}
iść: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ręka',natr)}
iść: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
iść: _: : imperf: subj{np(str)} + {preplexnp(w,acc,pl,'ślad',ratr)}
iść: _: : imperf: subj{np(str)} + {preplexnp(z,inst,pl,'torba',natr)}
iść: _: : imperf: subj{np(str)} + {preplexnp(z,inst,sg,'dym',natr)}
iść: _: : imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
iść: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
iść: _: : imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
iść: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
iść: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
iść: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
iść: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
iść: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
iść: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
iść: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'łóżko',natr)}
iść: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'para',atr)}
iść: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
izolować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
izolować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
izolować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
izolować: _: : _: subj{np(str)} + {prepnp(od,gen)} + {refl}
jadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
jadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
jadać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
jadać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
jałowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
jałowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
jarać się: _: : imperf: subj{np(str)} + {cp(int)}
jarać się: _: : imperf: subj{np(str)} + {cp(że)}
jarać się: _: : imperf: subj{np(str)} + {np(dat)}
jarać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
jarać się: _: : imperf: subj{np(str)} + {or}
jarać: _: : imperf: subj{cp(gdy)} + {np(str)}
jarać: _: : imperf: subj{cp(int)} + {np(str)}
jarać: _: : imperf: subj{cp(jak)} + {np(str)}
jarać: _: : imperf: subj{cp(jeśli)} + {np(str)}
jarać: _: : imperf: subj{cp(kiedy)} + {np(str)}
jarać: _: : imperf: subj{cp(że)} + {np(str)}
jarać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
jarać: _: : imperf: subj{np(str)} + obj{np(str)}
jarać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
jarzyć się: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
jarzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
jarzyć się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
jarzyć się: _: : imperf: subj{np(str)} + {xp(adl)}
jarzyć: _: : imperf: subj{np(str)} + {cp(int)}
jarzyć: _: : imperf: subj{np(str)} + {cp(że)}
jarzyć: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
jarzyć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
jasny: : : : {prepnp(dla,gen)}
jasny: : : : {prepnp(w,loc)}
jasny: : pred: : {prepnp(dla,gen)} + {cp(int)}
jasny: : pred: : {prepnp(dla,gen)} + {cp(że)}
jaśnieć: _: : imperf: subj{E} + {xp(locat)}
jaśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
jaśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
jawić się: _: : imperf: subj,controller{np(str)} + controllee{adjp(str)} + {np(dat)}
jawić się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
jawić się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
jawić się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(przed,inst)}
jawić się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
jawić się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
jawić się: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
jawić się: _: : imperf: subj{np(str)} + {xp(locat)}
jąć się: _: : perf: subj{np(str)} + {np(gen)}
jąć: _: : perf: subj,controller{E} + controllee{infp(imperf)}
jebać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
jebać: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)}
jebać: _: : imperf: {np(inst)} + {prepnp(od,gen)}
jebać: _: : imperf: {np(inst)} + {xp(locat)}
jebać: _: : imperf: subj{cp(int)} + {np(str)}
jebać: _: : imperf: subj{cp(że)} + {np(str)}
jebać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
jebać: _: : imperf: subj{np(str)} + {np(inst)}
jebać: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
jebać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
jechać: _: : imperf: {np(inst)} + {prepnp(od,gen)}
jechać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
jechać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
jechać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
jechać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
jechać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
jechać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
jechać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {fixed('na jednym wózku')}
jednoczyć się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
jednoczyć się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
jednoczyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
jednoczyć się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
jednoczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
jednoczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
jednoczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
jednoczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
jednoznaczny: : : : {prepnp(co do,gen); prepncp(co do,gen,że)}
jednoznaczny: : : : {prepnp(w,loc)}
jednoznaczny: : : : {prepnp(z,inst); prepncp(z,inst,że)}
jednoznaczny: : pred: : {cp(że)}
jednoznaczny: : pred: : {or}
jeść: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
jeść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
jeść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
jeść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
jeść: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
jeździć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
jeździć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
jeździć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
jeździć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
jęczeć: _: : imperf: subj{np(str)} + {cp(żeby)}
jęczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
jęczeć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
jęczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
jęczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
jęczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
jęczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
jęczeć: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {or}
jęczeć: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
jęczeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
jędrnieć: _: : imperf: subj{np(str)}
jęknąć: _: : perf: subj{np(str)} + {cp(że)}
jęknąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
jęknąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
jęknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
jęknąć: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {or}
jęknąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
jęknąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
jodynować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
jonizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
juczyć: _: : imperf: subj{np(str)} + obj{np(str)}
kadrować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
kadrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
kalać się: _: : imperf: subj{np(str)} + {np(inst)}
kalać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
kalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kaleczyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kaleczyć się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
kaleczyć się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
kaleczyć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
kaleczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kaleczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
kaleczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kaleczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
kalkulować się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
kalkulować się: _: : imperf: subj{cp(żeby)} + {np(dat)}
kalkulować się: _: : imperf: subj{np(str)} + {advp(misc)}
kalkulować się: _: : imperf: subj{np(str)} + {np(dat)}
kalkulować: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
kalkulować: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
kalkulować: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
kalkulować: _: : imperf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
kalkulować: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
kampania: : : : {np(gen)} + {possp}
kampania: : : : {possp} + {comprepnp(na temat)}
kampania: : : : {possp} + {comprepnp(w sprawie)}
kampania: : : : {possp} + {cp(jakoby)}
kampania: : : : {possp} + {cp(że)}
kampania: : : : {possp} + {cp(żeby)}
kampania: : : : {possp} + {prepnp(o,acc); prepnp(przeciw,dat); prepnp(za,inst); comprepnp(na rzecz); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)}
kampania: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby)}
kanalizować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kanalizować się: _: : imperf: subj{np(str)} + {xp(locat)}
kanalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kanalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
kanalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
kandydat: : : : {possp} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
kandydat: : : : {possp} + {prepnp(przeciw,dat)}
kandydować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
kandydować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
kanonizować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
kapać: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
kapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
kapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
kapać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
kapać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kapitulować: _: : _: subj{np(str)} + {prepnp(przed,inst)}
kapitulować: _: : _: subj{np(str)} + {prepnp(wobec,gen)}
kapnąć się: _: : perf: subj{np(str)} + {cp(int)}
kapnąć się: _: : perf: subj{np(str)} + {cp(że)}
kapnąć: _: : perf: {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
kapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
kapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
kapnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
kapować: _: : imperf: subj{np(str)} + {cp(int)}
kapować: _: : imperf: subj{np(str)} + {cp(że)}
kapować: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
kapować: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
kapować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kaprysić: _: : imperf: subj{np(str)} + {comprepnp(co do)}
kaprysić: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
kaprysić: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
kaprysić: _: : imperf: subj{np(str)} + {cp(że)}
kaprysić: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
kaprysić: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kara: : : : {cp(że)}
kara: : : : {np(gen)} + {possp} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
kara: : : : {np(gen)} + {prepnp(dla,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
kara: : : : {possp} + {comprepnp(w stosunku do)}
kara: : : : {possp} + {prepnp(wobec,gen)}
kara: : : : {possp} + {prepnp(względem,gen)}
karać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
karać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
karać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
karcić: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
karcić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
karcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
karcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
karcić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {or}
karcić: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {or} + {refl}
karczować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
karczować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
karmić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
karmić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kartkować: _: : imperf: subj{np(str)} + obj{np(str)}
kasować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
kasować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(abl)}
kasować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
kasować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
katować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
katować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
katować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
kazać: _: : _: subj{ncp(str,że)} + controller{np(dat)} + controllee{infp(_)}
kazać: _: : _: subj{np(str)} + controller{np(dat)} + controllee{cp(żeby); infp(_)}
kazać: _: : _: subj{np(str)} + {np(dat)} + {np(str)}
kazać: _: : _: subj{np(str)} + {np(dat)} + {or}
kazić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kazić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kąpać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kąpać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kąpać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
kąsać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
kąsać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
kąsać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kąsać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
kąsać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kibicować: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
kibicować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
kibicować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kichać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kichać: _: : imperf: subj{np(str)} + {np(inst)}
kichać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
kiełkować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kierować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
kierować się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
kierować się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
kierować się: _: : imperf: subj{np(str)} + {xp(adl)}
kierować: _: : imperf: subj{np(str)} + obj{np(inst); ncp(inst,int)}
kierować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
kierować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
kierować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
kierowca: : : : {fixed('niedzielny')}
kierowca: : : : {np(gen)} + {possp}
kierownictwo: : : : {adjp(agr)} + {possp} + {prepnp(nad,inst)} + {xp(locat)}
kierownictwo: : : : {np(gen)} + {possp}
kierownictwo: : : : {np(inst)} + {possp}
kierownictwo: : : : {possp} + {prepnp(ku,dat)}
kierunek: : : : {np(gen)} + {possp} + {prepnp(na,loc)}
kierunek: : : : {np(gen)} + {possp} + {prepnp(w,loc)}
kierunek: : : : {xp(abl)} + {xp(adl)}
kierunkowy: : : : {np(gen)}
kierunkowy: : : : {prepnp(do,gen)}
kipieć: _: : imperf: subj{E} + {prepnp(od,gen)} + {xp(locat)}
kipieć: _: : imperf: subj{E} + {prepnp(w,loc)} + {prepnp(z,gen)}
kipieć: _: : imperf: subj{np(str)} + {np(inst)}
kipieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kipieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
kipieć: _: : imperf: subj{np(str)} + {xp(abl)}
kipieć: _: : imperf: subj{np(str)} + {xp(adl)}
kiwać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
kiwać: _: : imperf: subj{np(str)} + obj{np(str)}
kiwnąć się: _: : perf: subj{np(str)}
kiwnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
kiwnąć: _: : perf: subj{np(str)} + obj{np(str)}
klamrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
klapać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
klapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
klapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
klapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
klapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klapać: _: : imperf: subj{np(str)} + {xp(adl)}
klapnąć się: _: : perf: subj{np(str)} + {xp(adl)}
klapnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
klapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
klapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
klapnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
klapnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klapnąć: _: : perf: subj{np(str)} + {xp(adl)}
klarowny: : : : {prepnp(dla,gen)}
klarowny: : : : {prepnp(w,loc)}
klarowny: : pred: : {prepnp(dla,gen)} + {cp(że)}
klaskać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
klaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klaskać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
klasyfikować się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
klasyfikować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
klasyfikować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
klasyfikować się: _: : imperf: subj{np(str)} + {xp(locat)}
klasyfikować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
klasyfikować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
klasyfikować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
klasyfikować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
klasyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
klasyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
klasyfikować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
klasyfikować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
kląć się: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
kląć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
kląć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
kląć: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
kląć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
kleić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
kleić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
kleić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(z,inst)}
kleić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
kleić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
kleić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
kleić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,acc)} + {prepnp(z,inst)}
kleić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
klekotać: _: : imperf: subj{np(str)} + {cp(że)}
klekotać: _: : imperf: subj{np(str)} + {cp(żeby)}
klekotać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
klekotać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
klekotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
klekotać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
klepać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
klepać: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
klepać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
klepać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klepać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
klepać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
klepać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
klepać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(do,gen)}
klepać: _: : imperf: subj{np(str)} + obj{cp(że); cp(żeby)} + {np(dat)}
klepać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
klepać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
klepać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klepać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
klepać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
klepać: _: : imperf: subj{np(str)} + {or}
klepać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
klepać: _: : imperf: subj{np(str)} + {xp(locat)} + {lexnp(str,sg,'bieda',natr)}
klepnąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
klepnąć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'ozór',atr)}
klepnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klepnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
klepnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
klepnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
klepnąć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
klepnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
klepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
klepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
klepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
klepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
klepnąć: _: : perf: subj{np(str)} + {or}
klęczeć: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
klęczeć: _: : imperf: subj{np(str)} + {xp(locat)}
klękać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {preplexnp(na,acc,_,'kolano',natr)}
klękać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {preplexnp(na,loc,_,'kolano',natr)}
klękać: _: : imperf: subj{np(str)} + {xp(locat)} + {preplexnp(na,acc,_,'kolano',natr)}
klękać: _: : imperf: subj{np(str)} + {xp(locat)} + {preplexnp(na,loc,_,'kolano',natr)}
klęknąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {preplexnp(na,acc,_,'kolano',natr)}
klęknąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {preplexnp(na,loc,_,'kolano',natr)}
klęknąć: _: : perf: subj{np(str)} + {xp(locat)} + {preplexnp(na,acc,_,'kolano',natr)}
klęknąć: _: : perf: subj{np(str)} + {xp(locat)} + {preplexnp(na,loc,_,'kolano',natr)}
klikać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
klikać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klikać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
klikać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
klikać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
kliknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kliknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kliknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
kliknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
klimatyzować: _: : imperf: subj{np(str)} + obj{np(str)}
klimatyzować: _: : imperf: subj{np(str)} + {refl}
klonować: _: : imperf: subj{np(str)} + obj{np(str)}
klonować: _: : imperf: subj{np(str)} + {refl}
klucz: : : : {np(gen)} + {possp}
klucz: : : : {possp} + {cp(żeby)}
klucz: : : : {possp} + {prepnp(dla,gen)}
klucz: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,żeby)}
klucz: : : : {possp} + {prepnp(na,acc)}
klucz: : : : {possp} + {prepnp(od,gen)}
kluczyć: _: : imperf: subj{np(str)} + {comprepnp(co do)}
kluczyć: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
kluczyć: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
kluczyć: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
kluczyć: _: : imperf: subj{np(str)} + {cp(że)}
kluczyć: _: : imperf: subj{np(str)} + {or}
kluczyć: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
kluczyć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
kluczyć: _: : imperf: subj{np(str)} + {xp(adl)}
kluczyć: _: : imperf: subj{np(str)} + {xp(locat)}
kluczyć: _: : imperf: subj{np(str)} + {xp(perl)}
kłamać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
kłamać: _: : imperf: subj{np(str)} + {or}
kłamać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
kłamać: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
kłamstwo: : : : {adjp(agr)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)} + {prepnp(przed,inst); prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do); preplexnp(pod,inst,sg,'adres',atr)}
kłamstwo: : : : {adjp(agr)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {prepnp(wobec,gen)} + {cp(że)}
kłamstwo: : : : {np(gen)} + {possp}
kłamstwo: : : : {possp} + {comprepnp(na rzecz)}
kłamstwo: : : : {possp} + {comprepnp(w kwestii)}
kłamstwo: : : : {possp} + {cp(jakoby)}
kłamstwo: : : : {possp} + {preplexnp(pod,inst,sg,'wzgląd',atr)}
kłamstwo: : : : {possp} + {preplexnp(w,loc,sg,'dziedzina',atr)}
kłamstwo: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,jakoby); prepncp(co do,gen,że)} + {prepnp(przed,inst)}
kłamstwo: : : : {possp} + {prepnp(przeciw,dat)}
kłamstwo: : : : {possp} + {prepnp(przed,inst); prepnp(wobec,gen)} + {comprepnp(w sprawie)}
kłamstwo: : : : {possp} + {prepnp(wobec,gen)} + {or}
kłamstwo: : : : {possp} + {prepnp(wokół,gen)}
kłaniać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(od,gen)}
kłaniać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'pas',natr)}
kłaniać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
kłaść się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
kłaść się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
kłaść się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
kłaść się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kłaść się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
kłaść: _: : imperf: subj{np(str)} + {lexnp(str,pl,'ucho',natr)} + {preplexnp(po,loc,_,'siebie',natr)}
kłaść: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(w,acc,pl,'ucho',natr)}
kłaść: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,pl,'ucho',natr)}
kłaść: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,pl,'ucho',natr)}
kłaść: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'ucho',natr)} + {or}
kłaść: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{fixed('spać')}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(dla,gen)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(przy,loc)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(w,acc)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(w,loc)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'głowa',natr)} + {cp(że)} + {preplexnp(pod,acc,sg,'topór',natr)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'koniec',natr)} + {np(dat)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'kres',natr)} + {np(dat)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'krzyżyk',natr)} + {prepnp(na,loc)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'łapa',natr)} + {prepnp(na,loc)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'ręka',natr)} + {prepnp(na,loc)}
kłaść: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'tama',natr)} + {np(dat)}
kłaść: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(inst,sg,'trup',natr)}
kłaść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {lexnp(inst,sg,'łopata',natr)}
kłaść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
kłaść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
kłaść: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'łopatka',atr)}
kłaść: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'karb',ratr)}
kłaść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
kłębić się: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)} + {or}
kłębić się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
kłębić się: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
kłębić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
kłębić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kłębić się: _: : imperf: subj{np(str)} + {xp(locat)}
kłopot: : : : {possp} + {cp(int)}
kłopot: : : : {possp} + {cp(że)}
kłopot: : : : {possp} + {cp(żeby)}
kłopot: : : : {possp} + {prepnp(o,acc)}
kłopot: : : : {possp} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
kłopot: : : : {possp} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)} + {comprepnp(z powodu)}
kłopot: : : : {prepnp(dla,gen)}
kłopotać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
kłopotać się: _: : imperf: subj{np(str)} + {cp(int)}
kłopotać się: _: : imperf: subj{np(str)} + {cp(że)}
kłopotać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
kłopotać się: _: : imperf: subj{np(str)} + {or}
kłopotać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
kłopotać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
kłopotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
kłosić się: _: : imperf: subj{np(str)} + {xp(temp)}
kłócić się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
kłócić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
kłócić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kłuć: _: : imperf: {np(str)} + {xp(locat)}
kłuć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
kłuć: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
kłuć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kłuć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kłusować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kłusować: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
kneblować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
kneblować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
knuć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
kochać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kochać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kochać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
kochać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
kochać: _: : imperf: subj{np(str)} + {refl}
kocić się: _: : imperf: subj{np(str)}
kocić: _: : imperf: subj{np(str)} + obj{np(str)}
koczować: _: : imperf: subj{np(str)} + {xp(locat)}
kodować się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {xp(locat)}
kodować się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
kodować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
kodować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {xp(locat)}
kodować: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {xp(locat)}
kodować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {xp(locat)}
kodować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {xp(locat)}
kodować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kodować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kojarzyć się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
kojarzyć się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
kojarzyć się: _: : imperf: subj{cp(jak)} + {np(dat)} + {advp(misc)}
kojarzyć się: _: : imperf: subj{cp(że)} + {np(dat)} + {advp(misc)}
kojarzyć się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,jak); prepncp(z,inst,jakby); prepncp(z,inst,że); prepncp(z,inst,żeby)}
kojarzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
kojarzyć się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {advp(misc)}
kojarzyć się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
kojarzyć się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
kojarzyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
kojarzyć się: _: : imperf: subj{np(str)} + {xp(locat)} + {advp(misc)}
kojarzyć: _: : imperf: subj{np(str)} + {cp(int); cp(że)}
kojarzyć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
kojarzyć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
kojarzyć: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,jak); prepncp(z,inst,że); prepncp(z,inst,żeby)}
kojarzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
kojarzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {xp(locat)}
kokietować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
kokietować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
kokietować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
kolacjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kolebać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
kolebać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
kolebać: _: : imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
kolebać: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
kolebać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
kolebać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
kolebać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
kolegować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kolejka: : : : {adjp(agr)} + {possp} + {xp(abl)} + {xp(adl)}
kolejka: : : : {np(gen)} + {possp}
kolejka: : : : {np(gen)} + {prepnp(do,gen); prepnp(na,acc); prepnp(po,acc); prepnp(za,inst)}
kolejka: : : : {np(gen)} + {prepnp(do,gen)} + {prepnp(po,loc)}
kolekcjonować: _: : imperf: subj{np(str)} + obj{np(str)}
kolidować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
kolonizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kołatać się: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(po,loc)}
kołatać się: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
kołatać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
kołatać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kołatać się: _: : imperf: subj{np(str)} + {np(inst)}
kołatać się: _: : imperf: subj{np(str)} + {xp(perl)}
kołatać się: _: : imperf: subj{or} + {np(dat)} + {prepnp(po,loc)}
kołatać się: _: : imperf: subj{or} + {np(dat)} + {prepnp(w,loc)}
kołatać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
kołatać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kołatać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
kołatać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
kołatać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
kołatać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kołatać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
kołysać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
kołysać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
kołysać się: _: : imperf: subj{np(str)} + {xp(locat)}
kołysać: _: : imperf: {np(inst)}
kołysać: _: : imperf: subj{np(str)} + {np(inst)}
kołysać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kołysać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
kombinować: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
kombinować: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
kombinować: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
kombinować: _: : imperf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
kombinować: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
kombinować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
kombinować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
kombinować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
kombinować: _: : imperf: subj{np(str)} + {prepnp(przy,loc)} + {nonch}
komenda: : : : {np(gen)} + {adjp(agr)} + {xp(locat)}
komenda: : : : {possp} + {prepnp(nad,inst)}
komenda: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {cp(że)}
komenda: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {cp(żeby)}
komenda: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {or}
komenda: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
komentarz: : : : {possp} + {comprepnp(na temat)}
komentarz: : : : {possp} + {comprepnp(w kwestii)}
komentarz: : : : {possp} + {comprepnp(w sprawie)}
komentarz: : : : {possp} + {comprepnp(w stosunku do)}
komentarz: : : : {possp} + {cp(int)}
komentarz: : : : {possp} + {cp(jakoby)}
komentarz: : : : {possp} + {cp(że)}
komentarz: : : : {possp} + {cp(żeby)}
komentarz: : : : {possp} + {or}
komentarz: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
komentarz: : : : {possp} + {prepnp(dla,gen)}
komentarz: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
komentarz: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
komentarz: : : : {possp} + {prepnp(wobec,gen)}
komentarz: : : : {possp} + {prepnp(względem,gen)}
komentować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
komisja: : : : {adjp(agr)} + {possp} + {comprepnp(na rzecz)}
komisja: : : : {adjp(agr)} + {possp} + {comprepnp(w sprawie)}
komisja: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)}
komisja: : : : {adjp(agr)} + {possp} + {prepnp(do,gen)}
komisja: : : : {adjp(agr)} + {possp} + {prepnp(przeciw,dat)}
komisja: : : : {adjp(agr)} + {possp} + {prepnp(wokół,gen)}
komisja: : : : {np(gen)} + {adjp(agr)} + {possp}
kompatybilny: : : : {comprepnp(w stosunku do)}
kompatybilny: : : : {prepnp(do,gen)}
kompatybilny: : : : {prepnp(w,acc)} + {prepnp(z,inst)}
kompatybilny: : : : {prepnp(w,loc)} + {prepnp(z,inst)}
kompatybilny: : : : {prepnp(wobec,gen)}
kompatybilny: : : : {prepnp(względem,gen)}
kompetencja: : : : {possp} + {comprepnp(co do); prepncp(co do,gen,żeby)}
kompetencja: : : : {possp} + {comprepnp(w kwestii)}
kompetencja: : : : {possp} + {comprepnp(w sprawie); preplexnp(z,gen,sg,'tytuł',atr)}
kompetencja: : : : {possp} + {comprepnp(w stosunku do)}
kompetencja: : : : {possp} + {cp(żeby)}
kompetencja: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,żeby)}
kompetencja: : : : {possp} + {prepnp(w,loc); preplexnp(w,loc,sg,'zakres',atr)}
kompetencja: : : : {possp} + {prepnp(względem,gen)}
kompetentny: : : : {comprepnp(w stosunku do)}
kompetentny: : : : {cp(żeby)}
kompetentny: : : : {prepnp(dla,gen)}
kompetentny: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
kompetentny: : : : {prepnp(w,loc); prepncp(w,loc,żeby)}
kompleks: : : : {np(gen)} + {adjp(agr)} + {possp}
kompleks: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)} + {possp}
kompleks: : : : {possp} + {comprepnp(na temat)}
kompleks: : : : {possp} + {comprepnp(w stosunku do)}
kompleks: : : : {possp} + {comprepnp(z powodu)}
kompleks: : : : {possp} + {cp(że)}
kompleks: : : : {possp} + {preplexnp(na,loc,sg,'punkt',atr)}
kompleks: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,że)}
kompleks: : : : {possp} + {prepnp(wobec,gen)}
kompleks: : : : {possp} + {prepnp(względem,gen)}
komplementarny: : : : {comprepnp(w stosunku do)}
komplementarny: : : : {prepnp(dla,gen)}
komplementarny: : : : {prepnp(do,gen)}
komplementarny: : : : {prepnp(wobec,gen)}
komplementarny: : : : {prepnp(względem,gen)}
komplementarny: : : : {prepnp(z,inst)}
komplementować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
komplementować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
komplementować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
komplementować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
kompletować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
kompletować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kompletować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
kompletować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
komplikować się: _: : imperf: subj{np(str)} + {np(dat)}
komplikować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
komplikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
komponować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
komponować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
komponować się: _: : imperf: subj{np(str)} + {xp(locat)}
komponować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
komponować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kompostować: _: : imperf: subj{np(str)} + obj{np(str)}
kompromitować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
kompromitować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
kompromitować: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(przed,inst)}
kompromitować: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(wobec,gen)}
kompromitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
kompromitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
komunikować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
komunikować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
komunikować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
komunikować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
komunikować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
konać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
konać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
konać: _: : imperf: subj{np(str)} + {prepnp(wskutek,gen)}
konać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
koncelebrować: _: : imperf: subj{np(str)} + obj{np(str)}
koncentrować się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
koncentrować się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że); prepncp(wokół,gen,żeby)}
koncentrować się: _: : imperf: subj{np(str)} + {xp(locat)}
koncentrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
koncentrować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
koncepcja: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)} + {possp}
koncepcja: : : : {possp} + {comprepnp(na temat)}
koncepcja: : : : {possp} + {comprepnp(w kwestii)}
koncepcja: : : : {possp} + {comprepnp(w sprawie)}
koncepcja: : : : {possp} + {cp(int)}
koncepcja: : : : {possp} + {cp(jakoby)}
koncepcja: : : : {possp} + {cp(że)}
koncepcja: : : : {possp} + {cp(żeby)}
koncepcja: : : : {possp} + {or}
koncepcja: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
koncepcja: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
koncepcja: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
koncert: : : : {adjp(agr)} + {possp} + {prepnp(na,acc)}
koncert: : : : {adjp(agr)} + {possp} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int)}
koncert: : : : {adjp(agr)} + {possp} + {prepnp(z,inst)}
koncert: : : : {np(gen)} + {adjp(agr)} + {possp} + {comprepnp(na rzecz)}
koncertować: _: : imperf: subj{np(str)} + {xp(locat)}
koncesjonować: _: : _: subj{np(str)} + obj{np(str)}
konfiskować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na rzecz)}
konflikt: : : : {adjp(agr); prepnp(między,inst); xp(locat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
konflikt: : : : {np(gen)} + {prepnp(między,inst)}
konflikt: : : : {np(gen)} + {prepnp(z,inst)}
konflikt: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,że)} + {prepnp(z,inst)}
konflikt: : : : {possp} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
konflikt: : : : {possp} + {prepnp(wokół,gen)} + {prepnp(z,inst)}
konflikt: : : : {possp} + {prepnp(z,inst)} + {comprepnp(na temat)}
konflikt: : : : {possp} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
konflikt: : : : {possp} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
konflikt: : : : {possp} + {prepnp(z,inst)} + {comprepnp(z powodu)}
konflikt: : : : {possp} + {prepnp(z,inst)} + {preplexnp(na,loc,sg,'tło',atr)}
konflikt: : : : {possp} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'zakres',atr)}
konflikt: : : : {possp} + {prepnp(z,inst)} + {preplexnp(z,gen,sg,'zakres',atr)}
konflikt: : : : {prepnp(co do,gen); prepncp(co do,gen,int)} + {prepnp(między,inst)}
konflikt: : : : {prepnp(między,inst)} + {comprepnp(na temat)}
konflikt: : : : {prepnp(między,inst)} + {comprepnp(w kwestii)}
konflikt: : : : {prepnp(między,inst)} + {comprepnp(z powodu)}
konflikt: : : : {prepnp(między,inst)} + {preplexnp(na,loc,sg,'tło',atr)}
konflikt: : : : {prepnp(między,inst)} + {preplexnp(w,loc,sg,'zakres',atr)}
konflikt: : : : {prepnp(między,inst)} + {preplexnp(z,gen,sg,'zakres',atr)}
konflikt: : : : {prepnp(między,inst)} + {prepnp(wokół,gen); comprepnp(w sprawie)}
konfrontować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
konfrontować: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)} + {refl}
koniec: : : : {lexnp(gen,pl,'koniec',natr)}
koniec: : : : {np(gen); ncp(gen,że)} + {possp}
koniec: : : : {possp} + {prepnp(z,inst); prepncp(z,inst,że)}
konieczny: : : : {np(dat)} + {prepnp(dla,gen); prepnp(do,gen); prepnp(na,acc); prepnp(w,loc); cp(żeby); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
konieczny: : : : {np(dat)} + {prepnp(przy,loc)}
konkludować: _: : imperf: subj{np(str)} + {cp(że)}
konkludować: _: : imperf: subj{np(str)} + {or}
konkretyzować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
konkretyzować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
konkretyzować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
konkretyzować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
konkretyzować: _: : imperf: subj{np(str)} + {or}
konkurencyjny: : : : {comprepnp(w stosunku do)}
konkurencyjny: : : : {prepnp(dla,gen)}
konkurencyjny: : : : {prepnp(do,gen)}
konkurencyjny: : : : {prepnp(wobec,gen)}
konkurencyjny: : : : {prepnp(względem,gen)}
konkurować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
konkurować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
konkurować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
konsekrować: _: : _: subj{np(str)} + {np(dat)} + {refl}
konsekrować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)}
konsekrować: _: : _: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wezwanie',atr)}
konsekrować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
konsekwencja: : : : {comprepnp(w kwestii)}
konsekwencja: : : : {comprepnp(w sprawie)}
konsekwencja: : : : {comprepnp(w stosunku do)}
konsekwencja: : : : {comprepnp(z powodu)}
konsekwencja: : : : {cp(że)}
konsekwencja: : : : {np(gen); ncp(gen,że)}
konsekwencja: : : : {possp} + {comprepnp(co do)}
konsekwencja: : : : {possp} + {prepnp(w,loc)}
konsekwencja: : : : {prepnp(dla,gen)}
konsekwencja: : : : {prepnp(wobec,gen)}
konsekwencja: : : : {prepnp(względem,gen)}
konsekwencja: : : : {prepnp(za,acc)}
konsekwentny: : : : {comprepnp(co do)}
konsekwentny: : : : {comprepnp(w kwestii)}
konsekwentny: : : : {comprepnp(w sprawie)}
konsekwentny: : : : {comprepnp(w stosunku do)}
konsekwentny: : : : {prepnp(dla,gen); prepnp(wobec,gen)}
konsekwentny: : : : {prepnp(w,loc)}
konsekwentny: : : : {prepnp(względem,gen)}
konsolidować się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
konsolidować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
konsolidować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
konsolidować się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
konsolidować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
konsolidować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
konsolidować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
konsolidować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
konsolidować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
konstatować: _: : imperf: subj{np(str)} + {cp(int)}
konstatować: _: : imperf: subj{np(str)} + {cp(że)}
konstatować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
konstatować: _: : imperf: subj{np(str)} + {or}
konstruować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
konstytuować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
konstytuować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
konstytuować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
konstytuować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
konstytutywny: : : : {prepnp(dla,gen)}
konstytutywny: : : : {prepnp(wobec,gen)}
konsultować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
konsultować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
konsultować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
konsultować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
konsultować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
konsultować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
konsultować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
konsultować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
konsultować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
konsumować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
konsumować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kontaktować się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)} + {comprepnp(na temat)}
kontaktować się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
kontaktować: _: : imperf: subj{np(str)}
kontaktować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kontemplować: _: : imperf: subj{np(str)} + {cp(int)}
kontemplować: _: : imperf: subj{np(str)} + {cp(że)}
kontemplować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
kontemplować: _: : imperf: subj{np(str)} + {or}
kontestować: _: : imperf: subj{np(str)} + obj{cp(int)}
kontestować: _: : imperf: subj{np(str)} + obj{cp(że)}
kontestować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
kontraktować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
kontraktować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kontrastować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
kontrastować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kontratakować: _: : imperf: subj{np(str)} + {np(inst)}
kontrola: : : : {adjp(agr)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
kontrola: : : : {adjp(agr)} + {possp} + {preplexnp(z,gen,sg,'zakres',atr)}
kontrola: : : : {adjp(agr)} + {possp} + {prepnp(nad,inst)} + {preplexnp(pod,inst,sg,'wzgląd',atr)}
kontrola: : : : {adjp(agr)} + {possp} + {prepnp(nad,inst)} + {preplexnp(w,loc,sg,'zakres',atr)}
kontrola: : : : {np(gen); adjp(agr); cp(int)} + {possp}
kontrola: : : : {np(gen)} + {adjp(agr)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {preplexnp(pod,inst,sg,'wzgląd',atr)}
kontrola: : : : {np(gen)} + {adjp(agr)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {preplexnp(w,loc,sg,'zakres',atr)}
kontrola: : : : {np(gen); ncp(gen,int); ncp(gen,że)} + {adjp(agr)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do)}
kontrola: : : : {np(gen)} + {np(inst)}
kontrola: : : : {np(gen)} + {possp} + {preplexnp(w,loc,sg,'dziedzina',atr)}
kontrola: : : : {np(gen)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {comprepnp(w kwestii)}
kontrola: : : : {np(gen)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {cp(int)}
kontrola: : : : {np(gen)} + {possp; preplexnp(z,gen,sg,'strona',atr)} + {prepnp(co do,gen); prepncp(co do,gen,int)}
kontrolować: _: : imperf: subj{np(str)} + {cp(int)} + {refl}
kontrolować: _: : imperf: subj{np(str)} + {cp(że)}
kontrolować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
kontrolować: _: : imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
kontrolować: _: : imperf: subj{np(str)} + {refl}
kontuzjować się: _: : _: subj{np(str)}
kontuzjować: _: : _: subj{np(str)} + obj{np(str)}
kontynuować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
konwojować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
kończyć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
kończyć się: _: : imperf: subj{np(str)} + {np(inst)}
kończyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kończyć się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
kończyć: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
kończyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
kończyć: _: : imperf: subj{np(str)} + {np(str)}
kończyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kończyć: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
kończyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kończyć: _: : imperf: subj{np(str)} + {xp(locat)}
kooperować: _: : imperf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
kooperować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
koordynować: _: : imperf: subj{np(str)} + {np(inst)}
koordynować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kopać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)}
kopać się: _: : imperf: subj{np(str)} + {xp(adl)}
kopać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
kopać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
kopać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
kopać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
kopiować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kopiować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
kopnąć się: _: : perf: subj{np(str)} + {xp(adl)}
kopnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
kopnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
kopnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
korcić: _: : imperf: controller{np(str)} + controllee{infp(_)}
korcić: _: : imperf: {np(str)} + {cp(że)}
korcić: _: : imperf: {np(str)} + {cp(żeby)}
korcić: _: : imperf: {np(str)} + {prepnp(do,gen)}
korcić: _: : imperf: {np(str)} + {prepnp(na,acc)}
korcić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
korelować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
korelować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
korelować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
korespondować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)} + {advp(misc)}
korespondować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
korespondować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
korespondować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
korkować się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
korkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
korkować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
koronować: _: : _: subj{np(str)} + {np(inst)} + {refl}
koronować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
koronować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
koronować: _: : _: subj{np(str)} + {prepnp(na,acc)} + {refl}
korumpować się: _: : imperf: subj{np(str)}
korumpować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
korygować: _: : imperf: subj{np(str)} + {cp(że)}
korygować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
korygować: _: : imperf: subj{np(str)} + {or}
korzystać: _: : imperf: subj{np(str)} + {cp(że)}
korzystać: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
korzystać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
korzystny: : : : {prepnp(dla,gen)}
korzystny: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
korzystny: : : : {prepnp(w,loc)}
korzystny: : : : {xp(locat); xp(temp)}
korzystny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
korzystny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
korzystny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
korzystny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
korzystny: : pred: : {prepnp(dla,gen)} + {cp(że)}
korzystny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
kosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
kosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
kosztować: _: : imperf: subj{np(str)} + {np(str)} + {np(str)}
kosztować: _: : imperf: subj{np(str)} + obj{np(part)}
koślawić się: _: : imperf: subj{np(str)}
koślawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
kpić: _: : imperf: subj{np(str)} + {prepncp(z,gen,że)}
kpić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
kpić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
krajać się: _: : imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)}
krajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
krajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
krasić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
krasić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kraść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
krążyć: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
krążyć: _: : imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że); prepncp(wokół,gen,żeby)}
krążyć: _: : imperf: subj{np(str)} + {xp(locat)}
krążyć: _: : imperf: subj{np(str)} + {xp(perl)}
kredyt: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(na,acc)} + {prepnp(od,gen); prepnp(z,gen)} + {preplexnp(w,loc,sg,'wysokość',atr)} + {preplexnp(z,gen,sg,'tytuł',atr)}
kredyt: : : : {possp} + {prepnp(dla,gen)} + {lexnp(gen,sg,'zaufanie',natr)}
kredytować się: _: : imperf: subj{np(str)} + {np(inst)}
kredytować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kreować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {refl}
kreować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {refl}
kreować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
kreować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
kreować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kreskować: _: : imperf: subj{np(str)} + obj{np(str)}
kreślić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
krewny: : : : {np(dat)} + {np(part)} + {prepnp(za,acc)}
kręcić się: _: : imperf: {np(dat)} + {preplexnp(w,loc,sg,'głowa',atr)}
kręcić się: _: : imperf: subj{np(str)} + {np(dat)}
kręcić się: _: : imperf: subj{np(str)} + {prepnp(koło,gen)}
kręcić się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
kręcić się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że); prepncp(wokół,gen,żeby)}
kręcić się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
kręcić się: _: : imperf: subj{np(str)} + {xp(locat)}
kręcić: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
kręcić: _: : imperf: subj{np(str)} + {np(inst)} + {or}
kręcić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
krępować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
krępować się: _: : imperf: subj{np(str)} + {cp(że)}
krępować się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że)}
krępować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
krępować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
krępować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
krępować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
krępujący: : : : {prepnp(dla,gen)}
krępujący: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
krępujący: : pred: : {prepnp(dla,gen)} + {cp(jak)}
krępujący: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
krępujący: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
krępujący: : pred: : {prepnp(dla,gen)} + {cp(że)}
krępujący: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
krochmalić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
kroczyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
kroczyć: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
kroczyć: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
kroić się: _: : imperf: subj{np(str)} + {np(dat)}
kroić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
kroić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
krok: : : : {possp} + {comprepnp(na rzecz)} + {xp(adl)}
krok: : : : {possp} + {comprepnp(w kwestii)} + {comprepnp(w sprawie)} + {xp(adl)}
krok: : : : {possp} + {cp(żeby)}
krok: : : : {possp} + {prepnp(do,gen); prepnp(ku,dat); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(ku,dat,int); prepncp(ku,dat,że); prepncp(ku,dat,żeby)} + {xp(adl)}
krok: : : : {possp} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,żeby)} + {xp(adl)}
krok: : : : {possp} + {xp(abl)} + {xp(adl)} + {xp(perl)}
krok: : : : {possp} + {xp(adl)} + {preplexnp(w,loc,sg,'dziedzina',atr); preplexnp(w,loc,sg,'zakres',atr)}
krok: : : : {possp} + {xp(locat)}
kropić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kropić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
kropić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kropić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
kropić: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
kropkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
królować: _: : imperf: subj{np(str)} + {np(dat)}
królować: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
królować: _: : imperf: subj{np(str)} + {xp(locat)}
kruszyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kruszyć się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kruszyć się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
kruszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kruszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kruszyć: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {lexnp(str,_,'kopia',natr)}
krwawić się: _: : imperf: subj{lexnp(str,sg,'serce',natr)}
krwawić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'serce',natr)}
krwawić się: _: : imperf: subj{np(str)} + {np(inst)}
krwawić: _: : imperf: subj{lexnp(str,_,'serce',ratr)} + {comprepnp(z powodu)}
krwawić: _: : imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {comprepnp(z powodu)}
krwawić: _: : imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(że)}
krwawić: _: : imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {prepnp(z,gen)}
krwawić: _: : imperf: subj{lexnp(str,sg,'serce',ratr)} + {cp(że)}
krwawić: _: : imperf: subj{lexnp(str,sg,'serce',ratr)} + {prepnp(z,gen)}
krwawić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
krwawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
krwawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
krwawić: _: : imperf: subj{np(str)} + {xp(adl)}
krwawić: _: : imperf: subj{np(str)} + {xp(perl)}
kryć się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
kryć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
kryć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
kryć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kryć się: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
kryć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kryć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
kryć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kryć: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
krytykować: _: : imperf: subj{np(str)} + obj{cp(int)}
krytykować: _: : imperf: subj{np(str)} + obj{cp(że)}
krytykować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
krytykować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
krytykować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
krytykować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
krytykować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
krzątać się: _: : imperf: subj{np(str)} + {prepnp(koło,gen)}
krzątać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
krzątać się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
krzątać się: _: : imperf: subj{np(str)} + {xp(locat)}
krzyczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
krzyczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
krzyczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
krzyczeć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
krzyczeć: _: : imperf: subj{np(str)} + {np(str); cp(że); cp(żeby)} + {prepnp(do,gen)}
krzyczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc)}
krzyczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(za,inst)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {nonch}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
krzyczeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
krzyk: : : : {np(gen)} + {possp}
krzyk: : : : {possp} + {comprepnp(na temat)}
krzyk: : : : {possp} + {comprepnp(w kwestii)}
krzyk: : : : {possp} + {comprepnp(w sprawie)}
krzyk: : : : {possp} + {comprepnp(z powodu)}
krzyk: : : : {possp} + {cp(int); cp(że)}
krzyk: : : : {possp} + {cp(żeby)}
krzyk: : : : {possp} + {prepnp(do,gen)} + {or}
krzyk: : : : {possp} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {or}
krzyk: : : : {possp} + {prepnp(wobec,gen)}
krzyk: : : : {possp} + {prepnp(wokół,gen)}
krzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
krzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
krzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
krzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
krzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
krzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
krzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
krzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); cp(żeby)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {nonch}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
krzyknąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
krzywdzący: : : : {comprepnp(w stosunku do)}
krzywdzący: : : : {prepnp(dla,gen)}
krzywdzący: : : : {prepnp(wobec,gen)}
krzywdzący: : : : {prepnp(względem,gen)}
krzywdzący: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
krzywdzący: : pred: : {prepnp(dla,gen)} + {cp(jak)}
krzywdzący: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
krzywdzący: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
krzywdzący: : pred: : {prepnp(dla,gen)} + {cp(że)}
krzywdzący: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
krzywdzić: _: : imperf: subj{cp(int)} + {np(str)}
krzywdzić: _: : imperf: subj{cp(że)} + {np(str)}
krzywdzić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
krzywdzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
krzywdzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
krzywdzić: _: : imperf: subj{np(str)} + {refl}
krzywić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
krzywić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
krzywić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
krzywić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
krzywić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
krzywić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
krzyżować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {xp(locat)}
krzyżować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
krzyżować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kserować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
książka: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {preplexnp(z,gen,sg,'dziedzina',atr)}
książka: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {preplexnp(z,gen,sg,'zakres',atr)}
książka: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)}
książka: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(od,gen)}
książka: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(o,loc); prepnp(z,gen); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
książka: : : : {adjp(agr); prepnp(dla,gen); prepnp(o,loc)} + {possp}
książka: : : : {np(gen)} + {possp}
książka: : : : {possp} + {prepnp(dla,gen)} + {prepnp(przeciw,dat)}
księga: : : : {adjp(agr)} + {possp} + {comprepnp(w sprawie)}
księga: : : : {adjp(agr)} + {prepnp(dla,gen); prepnp(ku,dat)}
księga: : : : {np(gen)} + {possp}
księga: : : : {possp} + {preplexnp(z,gen,sg,'dziedzina',atr)}
księga: : : : {possp} + {preplexnp(z,gen,sg,'zakres',atr)}
księga: : : : {possp} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)}
księgować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
księgować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
księgować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
księgować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
księgować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kształcić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kształcić się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
kształcić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kształcić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kształcić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
kształcić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kształtować się: _: : imperf: subj{np(str)} + {np(inst)}
kształtować się: _: : imperf: subj{np(str)} + {xp(locat)}
kształtować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kształtować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
kucharzyć: _: : imperf: subj{np(str)}
kuć: _: : imperf: subj{np(str)} + {lexnp(str,sg,'żelazo',natr)} + {fixed('póki gorące')}
kuć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kuć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat); prepnp(dla,gen)} + {np(inst)} + {prepnp(z,gen)}
kuć: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'blacha',natr)}
kuć: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pamięć',natr)}
kuć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
kulbaczyć: _: : imperf: subj{np(str)} + obj{np(str)}
kuleć: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
kuleć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kuleć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
kulić się: _: : imperf: subj{np(str)} + {xp(locat)}
kulić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kultywować: _: : imperf: subj{np(str)} + obj{np(str)}
kumulować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
kumulować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kumulować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kupić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc)}
kupić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(za,acc)} + {xp(locat)}
kupić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
kupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
kupować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
kupować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
kupować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kupować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
kupować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
kupować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
kupować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kurczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
kurczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
kurczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
kurczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
kursować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
kursować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
kursować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
kusić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
kusić się: _: : imperf: subj{np(str)} + {cp(żeby)}
kusić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
kusić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
kusić: _: : imperf: subj,controllee{infp(_)} + controller{np(str)}
kusić: _: : imperf: subj{cp(żeby)} + {np(str)}
kusić: _: : imperf: subj{cp(że)} + {np(str)}
kusić: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{infp(_)}
kusić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
kusić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
kusić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(żeby)}
kusić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
kusić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
kwalifikacje: : : : {adjp(agr); xp(adl)} + {possp}
kwalifikacje: : : : {np(gen)} + {prepnp(do,gen)}
kwalifikacje: : : : {np(gen); prepnp(z,gen); preplexnp(z,gen,sg,'dziedzina',atr); preplexnp(z,gen,sg,'zakres',atr)} + {possp}
kwalifikacje: : : : {possp} + {comprepnp(w kwestii)}
kwalifikacje: : : : {possp} + {comprepnp(w stosunku do)}
kwalifikacje: : : : {possp} + {cp(żeby)}
kwalifikacje: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,żeby)}
kwalifikacje: : : : {possp} + {prepnp(w,loc); preplexnp(w,loc,sg,'dziedzina',atr); preplexnp(w,loc,sg,'zakres',atr)}
kwalifikacje: : : : {possp} + {prepnp(względem,gen)}
kwalifikować się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
kwalifikować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
kwalifikować się: _: : imperf: subj{np(str)} + {cp(żeby)}
kwalifikować się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
kwalifikować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kwalifikować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
kwalifikować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
kwalifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
kwalifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
kwalifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kwapić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
kwapić się: _: : imperf: subj{np(str)} + {cp(żeby)}
kwapić się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
kwapić się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
kwapić się: _: : imperf: subj{np(str)} + {xp(adl)}
kwasić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kwasić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kwasić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kwaterować się: _: : imperf: subj{np(str)} + {xp(locat)}
kwaterować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kwestia: : : : {cp(jakoby)}
kwestia: : : : {fixed('życia i śmierci')}
kwestia: : : : {np(gen); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
kwestia: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(w,loc)}
kwestia: : : : {possp} + {prepnp(w,loc)} + {comprepnp(na temat)}
kwestia: : : : {possp} + {prepnp(w,loc)} + {cp(int)}
kwestia: : : : {possp} + {prepnp(w,loc)} + {cp(że)}
kwestia: : : : {possp} + {prepnp(w,loc)} + {or}
kwestia: : : : {prepnp(co do,gen)}
kwestionować: _: : imperf: subj{np(str)} + {cp(jakoby)}
kwestionować: _: : imperf: subj{np(str)} + obj{cp(int)}
kwestionować: _: : imperf: subj{np(str)} + obj{cp(że)}
kwestionować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
kwestować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
kwestować: _: : imperf: subj{np(str)} + {prepnp(dla,gen); prepnp(na,acc)} + {xp(locat)}
kwestować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
kwestować: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
kwestować: _: : imperf: subj{np(str)} + {xp(locat)} + {preplexnp(z,inst,_,'puszka',atr)}
kwitnąć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
kwitnąć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kwitować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
kwitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
kwitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
kwitować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
lać się: _: : imperf: {np(dat)} + {preplexnp(na,acc,pl,'głowa',natr)}
lać się: _: : imperf: {np(dat)} + {xp(abl)}
lać się: _: : imperf: {np(inst)} + {prepnp(z,gen)}
lać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
lać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
lać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,pl,'głowa',natr)}
lać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(przez,acc,pl,'ręka',natr)}
lać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
lać się: _: : imperf: subj{np(str)} + {xp(adl)}
lać się: _: : imperf: subj{np(str)} + {xp(locat)}
lać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
lać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
lać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
lać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
lać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
lakierować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
lakierować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
lakierować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
lamentować: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
lamentować: _: : imperf: subj{np(str)} + {cp(int)}
lamentować: _: : imperf: subj{np(str)} + {cp(że)}
lamentować: _: : imperf: subj{np(str)} + {or}
lamentować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
lansować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
lansować: _: : imperf: subj{np(str)} + {cp(że)}
lansować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
lansować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
lansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
lansować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
lansować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
lansować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
lansować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
latać: _: : imperf: subj{np(str)} + {np(dat)}
latać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
latać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
latać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
latać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
latać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
lawirować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
lawirować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
lawirować: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
lądować: _: : imperf: subj{np(str)} + {advp(misc)}
lądować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
lądować: _: : imperf: subj{np(str)} + {xp(locat)}
lecieć: _: : imperf: {np(dat)} + {advp(misc)}
lecieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
lecieć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
lecieć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
lecieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
lecieć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
lecieć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
lecieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
leczyć się: _: : imperf: subj{np(str)} + {np(dat)}
leczyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
leczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen)}
leczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
leczyć się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen)}
leczyć się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
leczyć się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
leczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
leczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
leczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
legalizować się: _: : imperf: subj{np(str)}
legalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
legenda: : : : {np(gen)} + {possp}
legenda: : : : {possp} + {comprepnp(na temat)}
legenda: : : : {possp} + {cp(int)}
legenda: : : : {possp} + {cp(jakoby)}
legenda: : : : {possp} + {cp(że)}
legenda: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)}
legenda: : : : {possp} + {prepnp(wokół,gen)}
lek: : : : {prepnp(dla,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
lek: : : : {prepnp(dla,gen)} + {prepnp(od,gen)}
lek: : : : {prepnp(dla,gen)} + {prepnp(po,loc)}
lek: : : : {prepnp(dla,gen)} + {prepnp(przeciw,dat)}
lekceważyć: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
lenić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
lenić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
lenić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
lenić się: _: : imperf: subj{np(str)} + {xp(locat)}
lenić się: _: : imperf: subj{np(str)} + {xp(temp)}
lenić: _: : imperf: subj{np(str)} + obj{np(str)}
leniuchować: _: : imperf: subj{np(str)}
lepić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
lepić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
lepić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
lepić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
lepić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
lepki: : : : {prepnp(od,gen)}
lepki: : : : {prepnp(z,gen)}
leżakować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
leżakować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
leżakować: _: : imperf: subj{np(str)} + {xp(dur)}
leżakować: _: : imperf: subj{np(str)} + {xp(locat)}
leżeć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(na,loc)}
leżeć: _: : imperf: subj{np(str); ncp(str,żeby)} + {prepnp(w,loc)}
leżeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
leżeć: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
leżeć: _: : imperf: subj{np(str)} + {xp(locat)}
lęk: : : : {np(gen)} + {possp}
lęk: : : : {possp} + {comprepnp(w stosunku do)}
lęk: : : : {possp} + {comprepnp(z powodu)}
lęk: : : : {possp} + {cp(gdy)}
lęk: : : : {possp} + {cp(int)}
lęk: : : : {possp} + {cp(jakoby)}
lęk: : : : {possp} + {cp(kiedy)}
lęk: : : : {possp} + {cp(że)}
lęk: : : : {possp} + {cp(żeby)}
lęk: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
lęk: : : : {possp} + {prepnp(o,acc); prepnp(przed,inst); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
lęk: : : : {possp} + {prepnp(wobec,gen)}
lęk: : : : {possp} + {prepnp(względem,gen)}
lękać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
lękać się: _: : imperf: subj{np(str)} + {cp(int)}
lękać się: _: : imperf: subj{np(str)} + {cp(że)}
lękać się: _: : imperf: subj{np(str)} + {cp(żeby)}
lękać się: _: : imperf: subj{np(str)} + {np(gen); ncp(str,int); ncp(str,że); ncp(str,żeby)}
lękać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
lgnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
lgnąć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
lgnąć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
liberalizować się: _: : imperf: subj{np(str)}
liberalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
licencjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
licować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
licować: neg: : imperf: subj{np(str)} + {prepnp(z,inst)}
liczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
liczyć: _: : imperf: subj{np(str)} + {np(str)}
liczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
liczyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
liczyć: _: : imperf: subj{np(str)} + {prepnp(na,acc); cp(że); prepncp(na,acc,że)}
liderować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
likwidować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
likwidować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
likwidować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
litościwy: : : : {comprepnp(w stosunku do)}
litościwy: : : : {prepnp(dla,gen)}
litościwy: : : : {prepnp(wobec,gen)}
litościwy: : : : {prepnp(względem,gen)}
litować się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
litować się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {or}
litować się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
lizać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
lizać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
lizać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
lizać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
lizać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
lizać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
lizać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
liznąć: _: : perf: subj{np(str)} + {np(gen)}
liznąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
liznąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
lobbować: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)} + {xp(locat)}
lobbować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(locat)}
lobbować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(locat)}
lobbować: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
lobbować: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)} + {xp(locat)}
logiczny: : : : {comprepnp(w kwestii)}
logiczny: : : : {prepnp(dla,gen)}
logiczny: : : : {prepnp(w,loc)}
logiczny: : pred: : {prepnp(dla,gen)} + {cp(że)}
logiczny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
lojalny: : : : {np(dat)}
lojalny: : : : {prepnp(wobec,gen); comprepnp(w stosunku do)}
lojalny: : : : {prepnp(względem,gen)}
lokalizować się: _: : imperf: subj{np(str)} + {xp(locat)}
lokalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
lokalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
lokować się: _: : imperf: subj{np(str)} + {xp(locat)}
lokować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
lokować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
lokować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
losować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
losować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
losować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spośród,gen)}
losować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
lubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
lubić: _: : imperf: subj,controller{np(str)} + controllee{np(str); cp(gdy); cp(jak); cp(jeśli); cp(kiedy); cp(że); cp(żeby); ncp(str,int); ncp(str,jak); ncp(str,że); infp(_)}
lubić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
lubować się: _: : imperf: subj{np(str)} + {np(inst)}
lubować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,jak); prepncp(w,loc,żeby)}
ludzki: : : : {prepnp(dla,gen)}
ludzki: : : : {prepnp(w,loc)}
ludzki: : pred: : {cp(że)}
ludzki: : pred: : {cp(żeby)}
lustrować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
lustrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
lustrować: _: : imperf: subj{np(str)} + {refl}
lżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
lżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
lżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
lżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ładować się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'życie',ratr)} + {preplexnp(z,inst,pl,'but',natr)}
ładować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
ładować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
ładować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ładować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
łagodnieć: _: : imperf: subj{np(str)} + {np(dat)}
łagodny: : : : {comprepnp(w stosunku do)}
łagodny: : : : {prepnp(dla,gen)}
łagodny: : : : {prepnp(w,loc)}
łagodny: : : : {prepnp(wobec,gen)}
łagodny: : : : {prepnp(względem,gen)}
łagodzić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
łagodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
łajać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
łajać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
łajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
łajać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
łaknąć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
łaknąć: _: : imperf: subj{np(str)} + {cp(żeby)}
łaknąć: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
łamać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
łamać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
łamać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
łamać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
łamać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
łamać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
łamać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
łamać: _: : imperf: {np(str)} + {prepnp(w,loc)}
łamać: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
łamać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
łamać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(str,pl,'ręka',natr)}
łamać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)} + {or}
łamać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
łamać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
łamać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,pl,'ręka',natr)}
łamać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
łamać: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'ząb',atr)}
łasić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
łasić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
łaskawy: : : : {comprepnp(w stosunku do)}
łaskawy: : : : {prepnp(dla,gen)}
łaskawy: : : : {prepnp(na,acc)}
łaskawy: : : : {prepnp(wobec,gen)}
łaskawy: : : : {prepnp(względem,gen)}
łaskotać: _: : imperf: {np(str)} + {prepnp(w,acc)}
łaskotać: _: : imperf: {np(str)} + {xp(locat)}
łaskotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
łaskotać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
łaskotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
łaskotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
łaskotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
łasy: : : : {np(gen)}
łasy: : : : {prepnp(na,acc)}
łatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
łatwy: : : : {prepnp(dla,gen); prepnp(do,gen)}
łatwy: : : : {prepnp(dla,gen)} + {prepnp(do,gen); prepnp(w,loc)}
łazić: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
łazić: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
łazić: _: : imperf: subj{cp(żeby)} + {prepnp(za,inst)}
łazić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
łazić: _: : imperf: subj{cp(że)} + {prepnp(za,inst)}
łazić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
łazić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
łazić: _: : imperf: subj{np(str)} + {prepnp(koło,gen)}
łazić: _: : imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
łazić: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
łazić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
łazić: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
łazić: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
łazić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
łączyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
łączyć się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
łączyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
łączyć: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(z,inst)}
łączyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
łączyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
łączyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
łeb: : : : {fixed('kocie')}
łeb: : : : {possp} + {fixed('barani')}
łeb: : : : {possp} + {fixed('zakuty')}
łeb: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,żeby)}
łechtać: _: : imperf: {np(str)} + {xp(locat)}
łechtać: _: : imperf: subj{cp(gdy)} + {np(str)}
łechtać: _: : imperf: subj{cp(int)} + {np(str)}
łechtać: _: : imperf: subj{cp(jak)} + {np(str)}
łechtać: _: : imperf: subj{cp(kiedy)} + {np(str)}
łechtać: _: : imperf: subj{cp(że)} + {np(str)}
łechtać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
łechtać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
łechtać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
łechtać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
łechtać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
łechtać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
łechtać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
łechtać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
łkać: _: : imperf: subj{np(str)} + {cp(że)}
łkać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
łkać: _: : imperf: subj{np(str)} + {np(inst)}
łkać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
łkać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {or}
łowić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
łowić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
łowić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
łożyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
łudzić się: _: : imperf: subj{cp(że)} + {np(dat)}
łudzić się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
łudzić się: _: : imperf: subj{np(str)} + {cp(że)}
łudzić się: _: : imperf: subj{np(str)} + {cp(żeby2)}
łudzić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
łudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(co do)}
łudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
łudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
łykać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
łykać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
łyknąć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
łyknąć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
łyknąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
machać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
machać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
machać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
machać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
machać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
machać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
machać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
machać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
machać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
machać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
machać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
machać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(inst,sg,'ręka',natr)}
machnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
machnąć się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
machnąć się: _: : perf: subj{np(str)} + {xp(adl)}
machnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
machnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
machnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
machnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
machnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
machnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
machnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
machnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
machnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
machnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
machnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
machnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
machnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
machnąć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(inst,sg,'ręka',natr)}
maczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
maczać: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)} + {lexnp(str,pl,'palec',natr)}
maić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
majaczyć się: _: : imperf: subj{cp(jakby)} + {np(dat)}
majaczyć się: _: : imperf: subj{cp(że)} + {np(dat)}
majaczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
majaczyć się: _: : imperf: subj{or} + {np(dat)}
majaczyć: _: : imperf: subj{cp(że)} + {np(dat)}
majaczyć: _: : imperf: subj{np(str)} + {cp(że)}
majaczyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
majaczyć: _: : imperf: subj{np(str)} + {np(str)}
majaczyć: _: : imperf: subj{or} + {np(dat)}
majstrować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
majstrować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
majstrować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
majstrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
majstrować: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
maleć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
malować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
malować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
malować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
malować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
malować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
małpować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
małpować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
małpować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
małpować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
małżeństwo: : : : {fixed('białe')}
małżeństwo: : : : {possp} + {prepnp(z,inst)}
małżeństwo: : : : {prepnp(między,inst)}
mamić: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
mamić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
mamić: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
mamić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
mamić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
mandat: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
mandat: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(od,gen)} + {preplexnp(w,loc,sg,'zakres',atr)}
mandat: : : : {adjp(agr)} + {possp} + {prepnp(od,gen)} + {prepnp(z,acc); prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); preplexnp(z,gen,sg,'tytuł',atr)} + {preplexnp(na,acc,sg,'kwota',atr); preplexnp(na,acc,sg,'suma',atr); preplexnp(w,loc,sg,'wysokość',atr)}
mandat: : : : {adjp(agr)} + {prepnp(dla,gen)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(na,acc,żeby)} + {prepnp(od,gen)}
mandat: : : : {adjp(agr)} + {prepnp(dla,gen)} + {prepnp(od,gen)} + {prepnp(z,acc); prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); preplexnp(z,gen,sg,'tytuł',atr)} + {preplexnp(na,acc,sg,'kwota',atr); preplexnp(na,acc,sg,'suma',atr); preplexnp(w,loc,sg,'wysokość',atr)}
mandat: : : : {np(gen)} + {possp} + {prepnp(dla,gen)} + {prepnp(od,gen)}
mandat: : : : {possp} + {comprepnp(w sprawie)}
mandat: : : : {possp} + {prepnp(do,gen)} + {cp(żeby)}
mandat: : : : {possp} + {prepnp(do,gen)} + {prepnp(o,loc)}
mandat: : : : {possp} + {prepnp(od,gen)} + {cp(żeby)}
manipulować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
manipulować: _: : imperf: subj{np(str)} + obj{np(inst)}
marnować się: _: : imperf: subj{np(str)}
marnować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
marnować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,_,'siebie',natr)}
marszczyć się: _: : imperf: subj{np(str)} + {np(dat)}
marszczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
marszczyć się: _: : imperf: subj{np(str)} + {xp(locat)}
marszczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
martwić się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
martwić się: _: : imperf: subj{np(str)} + {cp(int)}
martwić się: _: : imperf: subj{np(str)} + {cp(że)}
martwić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
martwić się: _: : imperf: subj{np(str)} + {or}
martwić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
martwić: _: : imperf: subj{cp(int)} + {np(str)}
martwić: _: : imperf: subj{cp(że)} + {np(str)}
martwić: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
marudzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
marudzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
marzenie: : : : {fixed('ściętej głowy')}
marzenie: : : : {np(gen)} + {possp}
marzenie: : : : {possp} + {comprepnp(na temat)}
marzenie: : : : {possp} + {comprepnp(w stosunku do)}
marzenie: : : : {possp} + {cp(int)}
marzenie: : : : {possp} + {cp(że)}
marzenie: : : : {possp} + {cp(żeby)}
marzenie: : : : {possp} + {ncp(gen,żeby)}
marzenie: : : : {possp} + {or}
marzenie: : : : {possp} + {prepnp(co do,gen)}
marzenie: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
marzenie: : : : {possp} + {prepnp(wobec,gen)}
marznąć: _: : imperf: subj{np(str)} + {fixed('do szpiku kości')}
marznąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
marznąć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'kość',natr)}
marznąć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'sopel',natr)}
marzyć się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
marzyć się: _: : imperf: subj{cp(żeby)} + {np(dat)}
marzyć się: _: : imperf: subj{cp(że)} + {np(dat)}
marzyć się: _: : imperf: subj{np(str)} + {np(dat)}
marzyć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
marzyć: _: : imperf: subj{np(str)} + {cp(że)}
marzyć: _: : imperf: subj{np(str)} + {or}
marzyć: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
masakrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
masować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
masować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
masować: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
maszerować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
maszerować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
matkować: _: : imperf: subj{np(str)} + {np(dat)}
mawiać: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{np(nom)}
mawiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
mawiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {or}
mawiać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
mawiać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
mazać się: _: : imperf: subj{np(str)} + {cp(że)}
mazać się: _: : imperf: subj{np(str)} + {np(inst)}
mazać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
mazać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
mazać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mdleć: _: : imperf: subj{lexnp(str,sg,'serce',natr)} + {prepnp(w,loc)}
mdleć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
mdleć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
meblować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mechanizować się: _: : imperf: subj{np(str)}
mechanizować: _: : imperf: subj{np(str)} + obj{np(str)}
mecz: : : : {np(gen)} + {np(nom)} + {prepnp(o,acc)}
mecz: : : : {np(gen)} + {possp} + {prepnp(o,acc)} + {prepnp(z,inst)}
mecz: : : : {np(gen)} + {prepnp(między,inst)} + {prepnp(o,acc)}
mecz: : : : {np(nom)} + {np(nom)} + {prepnp(o,acc)} + {prepnp(w,acc)}
mecz: : : : {np(nom)} + {np(nom)} + {prepnp(o,acc)} + {prepnp(w,loc)}
mecz: : : : {possp} + {prepnp(o,acc)} + {prepnp(w,acc)} + {prepnp(z,inst)}
mecz: : : : {possp} + {prepnp(o,acc)} + {prepnp(w,loc)} + {prepnp(z,inst)}
mecz: : : : {possp} + {prepnp(z,inst)} + {xp(locat)}
mecz: : : : {prepnp(między,inst)} + {prepnp(o,acc)} + {prepnp(w,acc)}
mecz: : : : {prepnp(między,inst)} + {prepnp(o,acc)} + {prepnp(w,loc)}
medal: : : : {np(agr)} + {np(gen)} + {possp} + {prepnp(na,acc); prepnp(w,loc)}
medal: : : : {np(agr)} + {np(gen)} + {prepnp(dla,gen)} + {prepnp(na,acc); prepnp(w,loc)}
medal: : : : {np(gen)} + {possp} + {preplexnp(z,gen,sg,'okazja',atr)}
medal: : : : {np(gen)} + {possp} + {prepnp(za,acc); prepncp(za,acc,że)}
medal: : : : {np(gen)} + {prepnp(dla,gen)} + {preplexnp(z,gen,sg,'okazja',atr)}
medal: : : : {np(gen)} + {prepnp(dla,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
medytować: _: : imperf: subj{np(str)} + {cp(int)}
medytować: _: : imperf: subj{np(str)} + {or}
medytować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
medytować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
meldować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
meldować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
meldować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
meldować się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
meldować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
meldować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
meldować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
meldować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
meldować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
meldować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
meldować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
meldować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
meldować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
meldować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
męczyć się: _: : imperf: subj{np(str)} + {cp(że)}
męczyć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
męczyć się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
męczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
męczyć: _: : imperf: subj{cp(kiedy)} + {np(str)}
męczyć: _: : imperf: subj{cp(że)} + {np(str)}
męczyć: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
męczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
mianować: _: : _: subj,controller{np(str)} + controllee{np(inst)} + {refl}
mianować: _: : _: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
mianować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mianować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
mianować: _: : _: subj{np(str)} + {prepnp(na,acc)} + {refl}
miara: : : : {np(gen); ncp(gen,int)} + {possp}
miara: : : : {possp} + {comprepnp(w stosunku do)}
miara: : : : {possp} + {cp(int)}
miara: : : : {possp} + {prepnp(w,loc)}
miara: : : : {possp} + {prepnp(wobec,gen)}
miara: : : : {possp} + {prepnp(względem,gen)}
miara: : : : {prepnp(z,gen)}
miażdżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
miąć się: _: : imperf: subj{np(str)} + {np(dat)}
miąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
miąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
miąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
mieć się: _: : imperf: {prepadjp(ku,dat)}
mieć się: _: : imperf: {prepnp(na,acc)}
mieć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
mieć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
mieć się: _: : imperf: subj{np(str)} + {prepadjp(ku,dat)}
mieć się: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'baczność',natr)}
mieć się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
mieć: _: : imperf: subj,controller{E} + controllee{infp(_)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,_,'ambicja',atr); lexnp(str,_,'chęć',atr); lexnp(str,_,'możliwość',atr); lexnp(str,_,'podstawa',atr); lexnp(str,_,'powód',atr); lexnp(str,_,'szansa',atr); lexnp(str,sg,'cierpliwość',atr); lexnp(str,sg,'czas',atr); lexnp(str,sg,'czelność',atr); lexnp(str,sg,'fantazja',atr); lexnp(str,sg,'interes',atr); lexnp(str,sg,'kaprys',atr); lexnp(str,sg,'możność',atr); lexnp(str,sg,'nadzieja',atr); lexnp(str,sg,'nieszczęście',atr); lexnp(str,sg,'obowiązek',atr); lexnp(str,sg,'ochota',atr); lexnp(str,sg,'odwaga',atr); lexnp(str,sg,'okazja',atr); lexnp(str,sg,'pech',atr); lexnp(str,sg,'pragnienie',atr); lexnp(str,sg,'prawo',atr); lexnp(str,sg,'przyjemność',atr); lexnp(str,sg,'serce',atr); lexnp(str,sg,'siła',atr); lexnp(str,sg,'sposobność',atr); lexnp(str,sg,'sumienie',atr); lexnp(str,sg,'szczęście',atr); lexnp(str,sg,'zamiar',atr); lexnp(str,sg,'zaszczyt',atr); lexnp(str,sg,'zdrowie',atr); lexnp(str,sg,'zwyczaj',atr); lexnp(str,sg,'śmiałość',atr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,_,'przyczyna',atr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'obyczaj',atr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'polecenie',natr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,_,'tendencja',atr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'imię',atr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'nazwisko',atr)}
mieć: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
mieć: _: : imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
mieć: _: : imperf: subj{np(str)} + {advp(misc)}
mieć: _: : imperf: subj{np(str)} + {advp(misc)} + {preplexnp(w,loc,_,'głowa',natr)}
mieć: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{prepadjp(za,acc)}
mieć: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{prepnp(za,acc)}
mieć: _: : imperf: subj{np(str)} + {lexnp(str,sg,'zdanie',atr)}
mieć: _: : imperf: subj{np(str)} + {ncp(str,że)} + {preplexnp(do,gen,_,'siebie',natr)}
mieć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {fixed('za złe')}
mieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,że)} + {fixed('za złe')}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(przed,inst,_,'siebie',natr)}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,sg,'głowa',natr)}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(u,gen)}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
mieć: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
mieć: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {nonch}
mieć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,gdy); prepncp(przeciw,dat,int); prepncp(przeciw,dat,jak); prepncp(przeciw,dat,kiedy); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {nonch}
mienić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
mienić się: _: : imperf: subj{np(str)} + {np(inst)}
mienić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
mienić: _: : imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
mienić: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
mienić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
mienić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
mierzyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
mierzyć: _: : imperf: subj{np(str)} + {lexnp(str,pl,'siła',natr)} + {preplexnp(na,acc,pl,'zamiar',natr)}
mierzyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
mierzyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
mierzyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
mierzyć: _: : imperf: subj{np(str)} + {np(str)}
mierzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
mierzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mierzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
mierzyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
mierzyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
mieszać się: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
mieszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
mieszać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
mieszać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
mieszać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
mieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
mieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
mieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
mieszkać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
mieszkać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
mieszkać: _: : imperf: subj{np(str)} + {xp(locat)}
mieścić się: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
mieścić się: _: : imperf: subj{cp(żeby2)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
mieścić się: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
mieścić się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
mieścić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
mieścić się: _: : imperf: subj{np(str)} + {xp(locat)}
mieścić: _: : imperf: subj{np(str)} + {np(str)}
miewać się: _: : imperf: subj{np(str)} + {advp(misc)}
miewać się: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'baczność',natr)}
miewać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,_,'ambicja',atr); lexnp(str,_,'chęć',atr); lexnp(str,_,'możliwość',atr); lexnp(str,_,'szansa',atr); lexnp(str,sg,'czas',atr); lexnp(str,sg,'czelność',atr); lexnp(str,sg,'kaprys',atr); lexnp(str,sg,'możność',atr); lexnp(str,sg,'nieszczęście',atr); lexnp(str,sg,'ochota',atr); lexnp(str,sg,'odwaga',atr); lexnp(str,sg,'okazja',atr); lexnp(str,sg,'pech',atr); lexnp(str,sg,'pragnienie',atr); lexnp(str,sg,'przyjemność',atr); lexnp(str,sg,'siła',atr); lexnp(str,sg,'sposobność',atr); lexnp(str,sg,'szczęście',atr); lexnp(str,sg,'zamiar',atr); lexnp(str,sg,'zaszczyt',atr); lexnp(str,sg,'zwyczaj',atr)}
miewać: _: : imperf: subj{np(str)} + {advp(misc)} + {preplexnp(w,acc,sg,'głowa',natr)}
miewać: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{prepnp(za,acc)}
miewać: _: : imperf: subj{np(str)} + {ncp(str,że)} + {preplexnp(do,gen,_,'siebie',natr)}
miewać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {fixed('za złe')}
miewać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,że)} + {fixed('za złe')}
miewać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(przed,inst,_,'siebie',natr)}
miewać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
miewać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
miewać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
miewać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
miewać: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
miękczyć się: _: : imperf: subj{np(str)}
miękczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mięknąć: _: : imperf: subj{np(str)} + {np(dat)}
mięknąć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
migać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
migać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
migać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
migać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
migać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
migać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
migać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
mignąć: _: : perf: subj{cp(że)} + {np(dat)} + {xp(locat)}
mignąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
mignąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
migotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
migotać: _: : imperf: subj{np(str)} + {np(inst)}
migotać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
mijać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
mijać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
mijać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
mijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
miksować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,loc)}
miksować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,inst)}
miksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
miksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,loc)}
miksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,inst)}
miksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(z,inst)}
miksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,inst)}
milczeć: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jak,str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
milczeć: _: : imperf: subj{np(str)} + {comprepnp(co do)}
milczeć: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
milczeć: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
milczeć: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
milczeć: _: : imperf: subj{np(str)} + {cp(int)}
milczeć: _: : imperf: subj{np(str)} + {cp(że)}
milknąć: _: : imperf: subj{np(str)}
miłosierny: : : : {comprepnp(w stosunku do)}
miłosierny: : : : {prepnp(dla,gen); prepnp(wobec,gen)}
miłosierny: : : : {prepnp(w,loc)}
miłosierny: : : : {prepnp(względem,gen)}
miłościwy: : : : {np(dat)}
miłościwy: : : : {prepnp(dla,gen)}
miłować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
mina: : : : {possp} + {cp(jakby)}
mina: : : : {possp} + {cp(że)}
minąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
minąć: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
minąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
minąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
minimalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
minować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
minować: _: : imperf: subj{np(str)} + {xp(locat)}
miotać się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
miotać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
miotać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
miotać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
miotać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
miotać się: _: : imperf: subj{np(str)} + {xp(locat)}
miotać: _: : imperf: {np(inst)} + {prepnp(po,loc)}
miotać: _: : imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
miotać: _: : imperf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
miotać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
miotać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
miotać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
miotać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(z,gen)} + {xp(adl)}
miotać: _: : imperf: subj{np(str)} + obj{np(inst)} + {xp(abl)} + {xp(adl)}
miotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
miotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
miotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
miotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
miotać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
mistrz: : : : {fixed('nad mistrze')}
mistrz: : : : {np(gen)} + {possp}
mistrz: : : : {np(gen)} + {prepnp(w,acc)}
mistrz: : : : {np(gen)} + {prepnp(w,loc)}
mistrz: : : : {np(gen)} + {xp(locat)}
mitrężyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
mizdrzyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
mizdrzyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
mizernieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
mknąć: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
młody: : : : {np(inst)}
młody: : : : {prepnp(o,acc)}
mniemać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
mniemać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
mniemać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
mnożyć się: _: : imperf: subj{np(str)}
mnożyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
mobilizować się: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
mobilizować się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
mobilizować się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
mobilizować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
mobilizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
mobilizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
mobilizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
mocny: : : : {comprepnp(w stosunku do)}
mocny: : : : {prepnp(o,acc)}
mocny: : : : {prepnp(w,loc)}
mocny: : : : {prepnp(wobec,gen)}
mocny: : : : {prepnp(względem,gen)}
mocny: : : : {prepnp(z,gen)}
mocować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
mocować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
mocować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
moczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
moczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
moczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
moczyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
moda: : : : {adjp(agr); prepnp(dla,gen); xp(adl)}
moda: : : : {cp(że)}
moda: : : : {cp(żeby)}
moda: : : : {np(gen)}
moda: : : : {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
modelować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
modelować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
modelować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
modelować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
modelować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
modlić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {or}
modlić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {cp(żeby)}
modlić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,inst)} + {cp(żeby)}
modlitwa: : : : {np(gen)} + {possp}
modlitwa: : : : {possp} + {prepnp(do,gen)} + {prepnp(nad,inst)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,żeby); prepncp(za,acc,żeby); preplexnp(w,loc,sg,'intencja',atr)}
modlitwa: : : : {possp} + {prepnp(za,inst)}
modlitwa: : : : {possp} + {xp(temp)}
modulować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
modyfikować się: _: : imperf: subj{np(str)}
modyfikować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)} + {np(inst)}
modyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
modyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
molestować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
molestować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
monitorować: _: : imperf: subj{np(str)} + {cp(int)}
monitorować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
montować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
montować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
moralizować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
moralizować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
moralizować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
mordować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
mordować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mordować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
mościć się: _: : imperf: subj{np(str)} + {xp(locat)}
mościć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mościć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
motywować: _: : imperf: subj{np(str)} + {cp(że)}
motywować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
motywować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
motywować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
motywować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
motywować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
motywować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
motywować: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
możliwy: : : : {prepnp(dla,gen)}
możliwy: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
możliwy: : pred: : {cp(że)}
możliwy: : pred: : {cp(żeby)}
możliwy: : pred: : {prepnp(przez,acc); prepncp(przez,acc,że); xp(mod)}
możliwy: : pred: : {prepnp(wskutek,gen)}
można: _: : imperf: {advp(pron)}
można: _: : imperf: {infp(_)}
móc: _: : imperf: subj,controller{E} + controllee{infp(_)}
móc: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
móc: _: : imperf: subj{np(str)} + {np(str)}
mrozić się: _: : imperf: subj{np(str)} + {np(dat)}
mrozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mruczeć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mruczeć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
mruczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
mruczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
mruczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
mruczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
mruczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
mruczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
mruczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
mrugać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
mrugać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
mrugnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
mrugnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
mruknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mruknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
mruknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
mruknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
mruknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
mruknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
mruknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
mruknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
mruknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
mrzeć: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
mrzeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
mrzeć: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
mrzeć: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
mścić się: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(na,loc)}
mścić się: _: : imperf: subj{np(str)} + {np(gen)} + {np(inst)} + {prepnp(na,loc)}
mścić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
mścić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
mścić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
murować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
murować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
musieć: _: : imperf: subj,controller{E} + controllee{infp(_)}
musieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
musieć: _: : imperf: subj{np(str)} + {xp(adl)}
muskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
muskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
muskać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
muskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
muskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
muskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
muskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
musnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
musnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
musnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
musnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
musnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
musnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
musnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
musztrować się: _: : imperf: subj{np(str)}
musztrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
muzykować: _: : imperf: subj{np(str)}
myć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
myć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mylić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepncp(z,inst,że)}
mylić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
mylić się: _: : imperf: subj{np(str)} + {prepncp(w,loc,że)}
mylić się: _: : imperf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
mylić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
mylić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
mylić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mylić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
myśl: : : : {possp} + {comprepnp(na temat)}
myśl: : : : {possp} + {comprepnp(w kwestii)}
myśl: : : : {possp} + {comprepnp(w sprawie)}
myśl: : : : {possp} + {cp(int)}
myśl: : : : {possp} + {cp(jakoby)}
myśl: : : : {possp} + {cp(że)}
myśl: : : : {possp} + {cp(żeby)}
myśl: : : : {possp} + {or}
myśl: : : : {possp} + {prepnp(co do,gen)}
myśl: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
myśleć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
myśleć: _: : imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{prepadjp(jako,str)}
myśleć: _: : imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{prepnp(jako,str)}
myśleć: _: : imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
myśleć: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
myśleć: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
myśleć: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
myśleć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nabawić się: _: : perf: subj{np(str)} + {np(gen)}
nabawić: _: : perf: subj{np(str)} + {np(gen)} + {np(str)}
nabazgrać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
nabazgrać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nabazgrać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
nabazgrać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
nabazgrać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
nabazgrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
nabazgrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
nabić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nabić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
nabić: _: : perf: subj{np(str)} + obj{np(part)}
nabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nabić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nabić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
nabierać się: _: : imperf: subj{np(str)} + {cp(że)}
nabierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabierać: _: : imperf: subj{np(str)} + {np(inst)} + {np(part)}
nabierać: _: : imperf: subj{np(str)} + {np(part)} + {prepnp(na,acc)}
nabierać: _: : imperf: subj{np(str)} + {np(part)} + {prepnp(w,acc)}
nabierać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
nabierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabijać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nabijać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
nabijać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
nabijać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabijać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabijać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
nabijać: _: : imperf: subj{np(str)} + obj{np(part)}
nabijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nabijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nabijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nabijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
nabrać się: _: : perf: subj{np(str)} + {cp(że)}
nabrać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabrać: _: : perf: subj{np(str)} + {np(part)} + {prepnp(na,acc)}
nabrać: _: : perf: subj{np(str)} + {np(part)} + {prepnp(w,acc)}
nabrać: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)}
nabrać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
nabrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabroić: _: : perf: subj{np(str)} + {nonch}
nabrzmiały: : : : {np(inst)}
nabrzmiały: : : : {prepnp(od,gen); prepncp(od,gen,że)}
nabrzmiały: : : : {prepnp(z,gen); prepncp(z,gen,że)}
nabrzmiały: : : : {xp(mod)}
nabrzmieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
nabrzmieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
nabrzmieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
nabrzmieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
nabrzmiewać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
nabrzmiewać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
nabrzmiewać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
nabrzmiewać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
nabuntować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nabuntować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,żeby)}
nabuntować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nabuntować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nabuntować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
nabyć się: _: : perf: subj{np(str)} + {xp(locat)}
nabyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
nabyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
nabyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
nabyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
nabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
nabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
nabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nacechować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
nacechować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nachmurzyć się: _: : perf: subj{np(str)}
nachmurzyć: _: : perf: subj{np(str)} + obj{np(str)}
nachodzić się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
nachodzić się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
nachodzić się: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
nachodzić się: _: : imperf: subj{np(str)} + {xp(adl)}
nachodzić: _: : imperf: subj{cp(żeby)} + {np(str)}
nachodzić: _: : imperf: subj{cp(że)} + {np(str)}
nachodzić: _: : imperf: subj{np(str)} + {np(inst)}
nachodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nachodzić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
nachwytać się: _: : perf: subj{np(str)} + {np(gen)}
nachwytać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nachylać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
nachylać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(ku,dat)}
nachylać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
nachylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
nachylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
nachylać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
nachylić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
nachylić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(ku,dat)}
nachylić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
nachylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
nachylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
nachylić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
naciąć się: _: : perf: subj{np(str)} + {np(gen)}
naciąć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
naciąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
naciąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
naciąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
naciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
naciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
naciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
naciągać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
naciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
naciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
naciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
naciągnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
naciągnąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)} + {xp(abl)} + {xp(adl)}
naciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
naciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
naciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
naciec: _: : perf: {np(dat)} + {np(gen)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
naciec: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
naciec: _: : perf: subj{np(str)} + {np(str)}
naciekać: _: : imperf: {np(dat)} + {np(gen)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
naciekać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
naciekać: _: : imperf: subj{np(str)} + {np(str)}
nacierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nacierać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nacierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nacierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nacierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nacierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
nacierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
nacierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
nacieszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
nacieszyć się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
nacieszyć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
nacinać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nacinać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
nacinać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nacinać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
nacinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
nacinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nacinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
naciskać: _: : perf: subj{np(str)} + {np(gen)} + {xp(adl)}
naciskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
naciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
naciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
naciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
naciskać: _: : imperf: subj{np(str)} + {or}
naciskać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
naciskać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
nacisnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nacisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nacisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nacisnąć: _: : perf: subj{np(str)} + {or}
nacjonalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
naczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
naćpać się: _: : perf: subj{np(str)} + {np(gen)}
naćpać się: _: : perf: subj{np(str)} + {np(inst)}
naćpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nadać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby)}
nadać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
nadać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
nadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
nadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nadarzać się: _: : imperf: subj{np(str)} + {np(dat)}
nadarzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
nadarzyć się: _: : perf: subj{np(str)} + {np(dat)}
nadarzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
nadawać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby)}
nadawać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
nadawać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
nadawać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
nadawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
nadawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nadążać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nadążać: _: : imperf: subj{np(str)} + {cp(żeby)}
nadążać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
nadążać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
nadążyć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
nadążyć: _: : perf: subj{np(str)} + {cp(żeby)}
nadążyć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
nadążyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
nadbiec: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadbiegać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadchodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
nadciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
nadciągać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadciągnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
naddać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
naddawać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
nadejść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
nadepnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nadepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadeptać się: _: : perf: subj{np(str)} + {np(gen)}
nadeptać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nadeptać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
nadeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nadeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
naderwać się: _: : perf: subj{np(str)} + {np(dat)}
naderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nadesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
nadesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
nadganiać: _: : imperf: subj{np(str)} + obj{np(str)}
nadgonić: _: : perf: subj{np(str)} + obj{np(str)}
nadgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadjechać: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadjeżdżać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadkładać: _: : imperf: subj{np(str)} + {np(str)} + {xp(adl)}
nadkładać: _: : imperf: subj{np(str)} + {np(str)} + {xp(perl)}
nadkładać: _: : imperf: subj{np(str)} + {xp(adl)} + {lexnp(gen,sg,'droga',natr)}
nadkładać: _: : imperf: subj{np(str)} + {xp(perl)} + {lexnp(gen,sg,'droga',natr)}
nadłamać się: _: : perf: subj{np(str)} + {np(dat)}
nadłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadłamywać się: _: : imperf: subj{np(str)} + {np(dat)}
nadłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadłożyć: _: : perf: subj{np(str)} + {np(str)} + {xp(adl)}
nadłożyć: _: : perf: subj{np(str)} + {np(str)} + {xp(perl)}
nadłożyć: _: : perf: subj{np(str)} + {xp(adl)} + {lexnp(gen,sg,'droga',natr)}
nadłożyć: _: : perf: subj{np(str)} + {xp(perl)} + {lexnp(gen,sg,'droga',natr)}
nadmieniać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
nadmieniać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
nadmieniać: _: : imperf: subj{np(str)} + obj{cp(jak)} + {np(dat)}
nadmieniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
nadmieniać: _: : imperf: subj{np(str)} + obj{nonch} + {np(dat)} + {comprepnp(na temat)}
nadmieniać: _: : imperf: subj{np(str)} + obj{nonch} + {np(dat)} + {comprepnp(w sprawie)}
nadmieniać: _: : imperf: subj{np(str)} + obj{nonch} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
nadmienić: _: : perf: subj{np(str)} + {np(dat)} + {or}
nadmienić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
nadmienić: _: : perf: subj{np(str)} + obj{cp(jak)} + {np(dat)}
nadmienić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
nadmienić: _: : perf: subj{np(str)} + obj{nonch} + {np(dat)} + {comprepnp(na temat)}
nadmienić: _: : perf: subj{np(str)} + obj{nonch} + {np(dat)} + {comprepnp(w sprawie)}
nadmienić: _: : perf: subj{np(str)} + obj{nonch} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
nadmuchać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nadmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nadmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
nadmuchiwać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nadmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nadmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
nadpalić się: _: : perf: subj{np(str)} + {np(dat)}
nadpalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadpłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
nadpłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {xp(adl)}
nadpłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
nadpłacić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {xp(adl)}
nadrabiać: _: : imperf: subj{np(str)} + {np(part)}
nadrabiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
nadrobić: _: : perf: subj{np(str)} + {np(part)}
nadrobić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
nadrobić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
nadrukować się: _: : perf: subj{np(str)} + {np(gen)}
nadrukować: _: : perf: subj{np(str)} + obj{np(part)} + {xp(locat)}
nadrukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nadrukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nadrukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nadrywać się: _: : imperf: subj{np(str)} + {np(dat)}
nadrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nadrzędny: : : : {comprepnp(w stosunku do)}
nadrzędny: : : : {prepnp(dla,gen)}
nadrzędny: : : : {prepnp(do,gen)}
nadrzędny: : : : {prepnp(nad,inst)}
nadrzędny: : : : {prepnp(wobec,gen)}
nadrzędny: : : : {prepnp(względem,gen)}
nadskakiwać: _: : imperf: subj{np(str)} + {np(dat)}
nadsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
nadsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
nadszarpać się: _: : perf: subj{np(str)} + {np(dat)}
nadszarpać: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
nadszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadszarpnąć się: _: : perf: subj{np(str)} + {np(dat)}
nadszarpnąć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
nadszarpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadszarpywać się: _: : imperf: subj{np(str)} + {np(dat)}
nadszarpywać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
nadszarpywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadsztukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadsztukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadużyć: _: : perf: subj{np(str)} + obj{np(gen)}
nadużywać: _: : imperf: subj{np(str)} + obj{np(gen)}
nadwątlać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
nadwątlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadwątlić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
nadwątlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadwrażliwy: : : : {preplexnp(na,loc,sg,'punkt',atr)}
nadwrażliwy: : : : {prepnp(na,acc)}
nadymić się: _: : perf: subj{E} + {xp(locat)}
nadymić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
nadymić: _: : perf: subj{np(str)} + {xp(abl)}
nadymić: _: : perf: subj{np(str)} + {xp(locat)}
nadzieja: : : : {adjp(agr)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
nadzieja: : : : {np(gen)} + {possp}
nadzieja: : : : {possp} + {comprepnp(w stosunku do)}
nadzieja: : : : {possp} + {cp(że)}
nadzieja: : : : {possp} + {cp(żeby)}
nadzieja: : : : {possp} + {prepnp(co do,gen)}
nadzieja: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nadzieja: : : : {possp} + {prepnp(wobec,gen)}
nadzieja: : : : {prepnp(dla,gen)}
nadziwić się: _: : perf: subj{np(str)} + {np(dat); cp(int); cp(że); ncp(dat,int); ncp(dat,że)}
nadzorować: _: : imperf: subj{np(str)} + obj{np(str)}
nadzwyczajny: : : : {comprepnp(w stosunku do)}
nadzwyczajny: : : : {prepnp(dla,gen)}
nadzwyczajny: : : : {prepnp(w,loc)}
nadzwyczajny: : : : {prepnp(wobec,gen)}
nadzwyczajny: : : : {prepnp(względem,gen)}
nadzwyczajny: : pred: : {cp(gdy)}
nadzwyczajny: : pred: : {cp(jak)}
nadzwyczajny: : pred: : {cp(jeśli)}
nadzwyczajny: : pred: : {cp(kiedy)}
nadzwyczajny: : pred: : {cp(że)}
nadzwyczajny: : pred: : {cp(żeby)}
nadźwigać się: _: : perf: subj{np(str)} + {np(gen)}
nadźwigać: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nafaszerować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
nafaszerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nagabywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
nagadać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
nagadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
nagadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
nagadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {np(part)}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {nonch}
nagadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
naganiać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
naganiać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
naganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
naganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nagarniać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nagiąć się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
nagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
nagiąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
nagimnastykować się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
nagimnastykować się: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,żeby)}
nagimnastykować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
naginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
naginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
naginać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
nagłaśniać: _: : imperf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
nagłaśniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
nagłaśniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
nagłośnić: _: : perf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
nagłośnić: _: : perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
nagłośnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
nagnać się: _: : perf: subj{np(str)} + {np(gen)}
nagnać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nagnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
nagnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nagonić się: _: : perf: subj{np(str)}
nagonić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nagonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
nagonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nagrać się: _: : perf: subj{np(str)} + {np(gen)}
nagrać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nagrać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
nagrać się: _: : perf: subj{np(str)} + {xp(locat)}
nagrać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
nagrać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
nagrać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {refl}
nagrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nagrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nagrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
nagrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
nagrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nagradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
nagradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nagradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nagrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
nagrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nagrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nagrywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
nagrywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
nagrywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
nagrywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
nagrywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {refl}
nagrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nagrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nagrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
nagrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
nagrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
naigrawać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
naigrawać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {fixed('w żywe oczy')}
naigrawać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
naigrawać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
naiwny: : : : {comprepnp(na temat)}
naiwny: : : : {comprepnp(w kwestii)}
naiwny: : : : {comprepnp(w sprawie)}
naiwny: : : : {comprepnp(w stosunku do)}
naiwny: : : : {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
naiwny: : : : {prepnp(w,loc); prepncp(w,loc,że)}
naiwny: : : : {prepnp(wobec,gen)}
naiwny: : : : {prepnp(względem,gen)}
naiwny: : pred: : {cp(gdy)}
naiwny: : pred: : {cp(jak)}
naiwny: : pred: : {cp(jeśli)}
naiwny: : pred: : {cp(kiedy)}
naiwny: : pred: : {cp(że)}
naiwny: : pred: : {cp(żeby)}
najechać się: _: : perf: subj{np(part)} + {xp(abl)} + {xp(adl)}
najechać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {xp(abl)}
najechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
najechać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
najechać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
najechać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
najechać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
najeść się: _: : perf: subj{np(str)} + {np(gen)}
najeść się: _: : perf: subj{np(str)} + {np(inst)}
najeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {xp(abl)}
najeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
najeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
najeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
najeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
najeżyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
najeżyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
najeżyć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
najeżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
najeżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
najść się: _: : perf: {np(gen)} + {xp(abl)} + {xp(adl)}
najść: _: : perf: {np(gen)} + {xp(abl)} + {xp(adl)}
najść: _: : perf: subj{cp(żeby)} + {np(str)}
najść: _: : perf: subj{cp(że)} + {np(str)}
najść: _: : perf: subj{np(str)} + {np(inst)}
najść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
najść: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nakarmić się: _: : perf: subj{np(str)} + {np(inst)}
nakarmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nakaz: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)} + {possp}
nakaz: : : : {possp} + {comprepnp(na temat)}
nakaz: : : : {possp} + {comprepnp(w sprawie)}
nakaz: : : : {possp} + {cp(jakoby)}
nakaz: : : : {possp} + {cp(że)}
nakaz: : : : {possp} + {cp(żeby)}
nakaz: : : : {possp} + {or}
nakaz: : : : {possp} + {prepnp(co do,gen)}
nakaz: : : : {possp} + {prepnp(o,loc)}
nakazać: _: : perf: subj{np(str)} + {np(dat)} + {or}
nakazać: _: : perf: subj{np(str)} + obj,controllee{cp(żeby); infp(_)} + controller{np(dat)}
nakazać: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
nakazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nakazywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
nakazywać: _: : imperf: subj{np(str)} + obj,controllee{cp(żeby); infp(_)} + controller{np(dat)}
nakazywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
nakazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nakierować się: _: : perf: subj{np(str)} + {np(inst)}
nakierować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nakierować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nakierować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
nakierowywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
nakierowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nakierowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
nakląć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
nakląć się: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
nakląć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nakląć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nakląć: _: : perf: subj{np(str)} + {np(str)} + {cp(że)}
nakląć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nakląć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nakład: : : : {adjp(agr)} + {preplexnp(o,loc,sg,'wartość',atr)}
nakład: : : : {fixed('per capita')}
nakład: : : : {np(gen); adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {preplexnp(w,loc,sg,'wysokość',atr)}
nakładać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
nakładać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'droga',natr)}
nakładać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nakładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nakłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
nakłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
nakłaść: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,_,'głowa',natr)}
nakłaść: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(w,acc,pl,'ucho',natr)}
nakłaść: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,_,'głowa',natr)}
nakłaść: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,pl,'ucho',natr)}
nakłaść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
nakłaść: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nakłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
nakłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
nakłuć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nakłuć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
nakłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakłuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nakłuwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nakłuwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nakłuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakłuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nakreślać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
nakreślać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
nakreślać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
nakreślać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
nakreślać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
nakreślić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
nakreślić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nakreślić: _: : perf: subj{np(str)} + {np(dat)} + {or}
nakreślić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
nakreślić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
nakręcać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
nakręcać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nakręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
nakręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nakręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nakręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nakręcać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
nakręcić się: _: : perf: subj{np(str)} + {np(inst)}
nakręcić: _: : perf: subj{np(str)} + {cp(że)} + {refl}
nakręcić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
nakręcić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
nakręcić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nakręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nakręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nakręcić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
nakrochmalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
nakruszyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nakruszyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nakruszyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nakryć: _: : perf: subj{lexnp(str,sg,'diabeł',natr)} + {np(str)} + {lexnp(inst,sg,'ogon',natr)}
nakryć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
nakryć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(gdy)} + {xp(locat)}
nakryć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {xp(locat)}
nakryć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(kiedy)} + {xp(locat)}
nakryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nakryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
nakrywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nakrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(gdy)} + {xp(locat)}
nakrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {xp(locat)}
nakrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(kiedy)} + {xp(locat)}
nakrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nakrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
nalać się: _: : perf: subj{np(part)} + {np(dat)} + {xp(adl)} + {xp(perl)}
nalać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nalać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nalatywać: _: : imperf: {np(dat)} + {np(gen)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nalatywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nalatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nalatywać: _: : imperf: subj{np(str)} + {np(str)}
nalatywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nalecieć: _: : perf: {np(dat)} + {np(gen)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nalecieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nalecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nalecieć: _: : perf: subj{np(str)} + {np(str)}
nalecieć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nalegać: _: : imperf: subj{np(str)} + {or}
nalegać: _: : imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
nalegać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nalegać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
nalewać się: _: : imperf: subj{np(part)} + {np(dat)} + {xp(adl)} + {xp(perl)}
nalewać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
należeć się: _: : perf: subj{np(str)} + {xp(locat)}
należeć się: _: : imperf: subj{cp(żeby)} + {np(dat)}
należeć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
należeć: _: : imperf: {advp(pron)}
należeć: _: : imperf: {infp(_)}
należeć: _: : imperf: subj{cp(żeby)} + {prepnp(do,gen)}
należeć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(do,gen)}
należny: : : : {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
należny: : : : {prepnp(do,gen)}
należny: : : : {prepnp(od,gen)}
naliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
naliczyć się: _: : perf: subj{np(str)} + {np(gen)}
naliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
naładować: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
naładować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nałamać się: _: : perf: subj{np(str)} + {np(gen)}
nałamać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
nałapać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)}
nałapać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
nałapać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
nałowić się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
nałowić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(na,acc)}
nałowić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(w,acc)}
nałowić się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
nałowić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
nałowić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
nałowić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,acc)}
nałowić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
nałowić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
nałożyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nałożyć: _: : perf: subj{np(str)} + {lexnp(gen,sg,'droga',natr)}
nałożyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nałożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nałupać się: _: : perf: subj{np(str)} + {np(gen)}
nałupać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
namartwić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
namartwić się: _: : perf: subj{np(str)} + {cp(int)}
namartwić się: _: : perf: subj{np(str)} + {cp(że)}
namartwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
namartwić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
namaszczać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
namaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
namaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
namaszczać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
namaścić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
namaścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
namaścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
namaścić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
namawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
namawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
namawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
namawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
namawiać: _: : imperf: subj{np(str)} + {or}
namieszać się: _: : perf: {np(dat)} + {prepnp(w,loc)}
namieszać się: _: : perf: {np(dat)} + {prepnp(z,inst)}
namieszać się: _: : perf: {np(dat)} + {xp(locat)}
namieszać się: _: : perf: subj{np(str)} + {np(gen)}
namieszać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
namieszać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
namieszać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
namieszać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
namówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
namówić: _: : perf: subj{np(str)} + {np(str)} + {prepncp(na,acc,żeby)}
namówić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(przeciw,dat)}
namówić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
namówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
namówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc)}
namyślać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
namyślać się: _: : imperf: subj{np(str)} + {cp(int)}
namyślać się: _: : imperf: subj{np(str)} + {cp(że)}
namyślać się: _: : imperf: subj{np(str)} + {cp(żeby)}
namyślać się: _: : imperf: subj{np(str)} + {or}
namyślać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
namyślać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
namyślić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
namyślić się: _: : perf: subj{np(str)} + {cp(int)}
namyślić się: _: : perf: subj{np(str)} + {cp(że)}
namyślić się: _: : perf: subj{np(str)} + {cp(żeby)}
namyślić się: _: : perf: subj{np(str)} + {or}
namyślić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
namyślić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
nanieść się: _: : perf: {np(part)} + {xp(abl)} + {xp(adl)}
nanieść się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nanieść: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
nanieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nanieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
nanieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
nanizać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
nanizać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
nanosić się: _: : _: {np(part)} + {xp(abl)} + {xp(adl)}
nanosić się: _: : _: subj{np(str)} + {xp(abl)} + {xp(adl)}
nanosić się: _: : perf: subj{np(str)} + {np(gen)}
nanosić: _: : _: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
nanosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nanosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
nanosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
naostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
naostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
naostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
napad: : : : {np(gen)} + {possp}
napad: : : : {possp} + {prepnp(na,acc)} + {prepnp(z,inst)}
napadać: _: : perf: subj{E} + {np(dat)} + {np(gen)} + {xp(adl)}
napadać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
napadać: _: : imperf: subj{cp(żeby)} + {np(str)}
napadać: _: : imperf: subj{nonch} + {np(str)} + {cp(żeby)}
napadać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
napadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
napadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
napakować się: _: : perf: subj{np(str)} + {np(gen)} + {xp(adl)}
napakować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
napakować: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {xp(adl)}
napakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
napaść się: _: : perf: subj{np(str)} + {np(inst)}
napaść: _: : perf: subj{cp(żeby)} + {np(str)}
napaść: _: : perf: subj{nonch} + {np(str)} + {cp(żeby)}
napaść: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
napaść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napaść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
napaść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
napatrzyć się: _: : perf: subj{np(str)} + {cp(int)}
napatrzyć się: _: : perf: subj{np(str)} + {cp(jak)}
napatrzyć się: _: : perf: subj{np(str)} + {cp(że)}
napatrzyć się: _: : perf: subj{np(str)} + {np(dat)}
napatrzyć się: _: : perf: subj{np(str)} + {np(gen)}
napatrzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że)}
napawać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
napawać: _: : imperf: subj{cp(gdy)} + {np(inst)} + {np(str)}
napawać: _: : imperf: subj{cp(int)} + {np(inst)} + {np(str)}
napawać: _: : imperf: subj{cp(jak)} + {np(inst)} + {np(str)}
napawać: _: : imperf: subj{cp(jeśli)} + {np(inst)} + {np(str)}
napawać: _: : imperf: subj{cp(kiedy)} + {np(inst)} + {np(str)}
napawać: _: : imperf: subj{cp(że)} + {np(inst)} + {np(str)}
napawać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {np(str)}
napawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napchać się: _: : perf: {np(part)} + {xp(adl)}
napchać się: _: : perf: subj{np(str)} + {xp(adl)}
napchać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
napchać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
napchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
napełniać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
napełniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
napełnić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
napełnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
napędzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
napędzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
napędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
napędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
napędzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
napędzić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
napędzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
napędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
napiąć się: _: : perf: subj{np(str)} + {np(dat)}
napiąć: _: : perf: subj{np(str)} + obj{np(str)}
napić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
napić się: _: : perf: subj{np(str)} + {np(inst)}
napierać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
napierać się: _: : imperf: subj{np(str)} + {cp(żeby)}
napierać się: _: : imperf: subj{np(str)} + {np(gen)}
napierać się: _: : imperf: subj{np(str)} + {xp(adl)}
napierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
napierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
napinać się: _: : imperf: subj{np(str)} + {np(dat)}
napinać: _: : imperf: subj{np(str)} + obj{np(str)}
napisać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
napisać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
napisać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
napisać: _: : perf: subj{np(str)} + {np(dat)} + {or}
napisać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
napisać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {or}
napisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
napisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
napisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
napisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int); cp(że); cp(żeby)}
napisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
napisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
napisać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {cp(int)}
napisać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
napleść się: _: : perf: subj{np(str)} + {np(gen)}
napleść: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
napleść: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
napleść: _: : perf: subj{np(str)} + {np(dat)} + {or}
napleść: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
napleść: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
naplotkować się: _: : perf: subj{np(str)} + {np(gen)}
naplotkować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
naplotkować się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
naplotkować się: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {cp(że)}
naplotkować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
naplotkować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
naplotkować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
naplotkować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
naplotkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
napłynąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
napłynąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
napłynąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
napłynąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
napłynąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
napływać się: _: : perf: subj{np(str)}
napływać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
napływać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
napływać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
napływać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
napływać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
napoić się: _: : perf: subj{np(str)} + {np(inst)}
napoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napompować się: _: : perf: subj{np(str)} + {np(gen)}
napompować się: _: : perf: subj{np(str)} + {np(inst)}
napompować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
napompować: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
napompować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
napotkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napotkać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
napotkać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
napotykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napotykać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
napotykać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
napracować się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
napracować się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
napracować się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
naprawiać się: _: : imperf: subj{np(str)}
naprawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
naprawić się: _: : perf: subj{np(str)}
naprawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
naprężać się: _: : imperf: subj{np(str)} + {np(dat)}
naprężać: _: : imperf: subj{np(str)} + obj{np(str)}
naprężyć się: _: : perf: subj{np(str)} + {np(dat)}
naprężyć: _: : perf: subj{np(str)} + obj{np(str)}
naprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
naprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
naprószyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
naprószyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
naprzeć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
naprzeć się: _: : perf: subj{np(str)} + {cp(żeby)}
naprzeć się: _: : perf: subj{np(str)} + {np(gen)}
naprzeć się: _: : perf: subj{np(str)} + {xp(adl)}
naprzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
naprzykrzać się: _: : imperf: subj,controllee{infp(imperf)} + controller{np(dat)}
naprzykrzać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
naprzykrzać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
naprzykrzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
naprzykrzyć się: _: : perf: subj,controllee{infp(imperf)} + controller{np(dat)}
naprzykrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
naprzynosić się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {xp(abl)} + {xp(adl)}
naprzynosić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
napuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
napuszać się: _: : imperf: subj{np(str)}
napuszać: _: : imperf: subj{np(str)} + obj{np(str)}
napuszyć się: _: : perf: subj{np(str)}
napuszyć: _: : perf: subj{np(str)} + obj{np(str)}
napychać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
napychać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
napychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
naradzać się: _: : imperf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
naradzać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(z,inst)}
naradzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
naradzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
naradzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
naradzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
naradzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(nad,inst,int)}
narastać: _: : imperf: {np(gen)} + {xp(locat)}
narastać: _: : imperf: subj{np(str)} + {np(dat)}
narastać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
narastać: _: : imperf: subj{np(str)} + {xp(dur)}
narastać: _: : imperf: subj{np(str)} + {xp(locat)}
narazić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
narazić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)} + {refl}
narazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)}
narazić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
narazić: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {refl}
narażać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
narażać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)} + {refl}
narażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)}
narażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
narażać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {refl}
narąbać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
narąbać się: _: : perf: subj{np(str)} + {np(gen)}
narąbać się: _: : perf: subj{np(str)} + {np(inst)}
narąbać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
naregulować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
narkotyzować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
narkotyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
narodzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
narodzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
narodzić: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
narodzić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
narosnąć: _: : perf: {np(gen)} + {xp(locat)}
narosnąć: _: : perf: subj{np(str)} + {np(dat)}
narosnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
narosnąć: _: : perf: subj{np(str)} + {xp(locat)}
narowić się: _: : imperf: subj{np(str)}
narowić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
naruszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
naruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
narwać się: _: : perf: subj{np(str)} + {np(gen)}
narwać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
narwać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
narysować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
narysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
narysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
narysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
narzekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
narzekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
narzekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
narzekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
narzędzie: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
narzędzie: : : : {np(gen)} + {possp} + {prepnp(dla,gen)}
narzędzie: : : : {possp} + {prepnp(dla,gen)} + {preplexnp(z,gen,sg,'zakres',atr)}
narzędzie: : : : {possp} + {prepnp(dla,gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
narzędzie: : : : {possp} + {prepnp(dla,gen)} + {prepnp(od,gen)}
narzucać się: _: : perf: subj{np(str)} + {np(gen)}
narzucać się: _: : perf: subj{np(str)} + {np(inst)}
narzucać się: _: : imperf: subj{cp(że)} + {np(dat)}
narzucać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
narzucać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
narzucać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
narzucać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
narzucać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
narzucać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
narzucać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
narzucać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
narzucać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
narzucić się: _: : perf: subj{cp(że)} + {np(dat)}
narzucić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
narzucić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
narzucić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)}
narzucić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
narzucić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
narzucić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
narzucić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
narżnąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {xp(adl)}
narżnąć się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
narżnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
narżnąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
narżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
nasadzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
nasadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nasadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nasadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
nasadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
nasadzić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nasadzić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
nasadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nasączać się: _: : imperf: subj{np(str)} + {np(inst)}
nasączać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nasączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nasączyć się: _: : perf: subj{np(str)} + {np(inst)}
nasączyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nasączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nasilać się: _: : imperf: subj{np(str)}
nasilać: _: : imperf: subj{np(str)} + obj{np(str)}
nasilić się: _: : perf: subj{np(str)}
nasilić: _: : perf: subj{np(str)} + obj{np(str)}
naskładać się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
naskładać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(na,acc)}
naskładać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(w,acc)}
naskładać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
naskładać się: _: : perf: subj{np(str)} + {np(gen)} + {xp(adl)}
naskładać się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
naskładać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
naskładać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
naskładać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
naskładać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(w,acc)}
naskładać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
naskładać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
naskładać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(locat)}
naskrobać się: _: : perf: subj{np(str)} + {np(gen)}
naskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
naskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
naskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
naskrobać: _: : perf: subj{np(str)} + {np(dat)} + {or}
naskrobać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
naskrobać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
naskrobać: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)}
naskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
naskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
naskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
naskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
naskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
naskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
naskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
naskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
naskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
naskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
nasłać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
nasłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nasłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nasłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
nasłuchać się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że); ncp(gen,żeby)} + {prepnp(od,gen)}
nasłuchać się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(na temat)}
nasłuchać się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
nasłuchać się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(jak)}
nasłuchać się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
nasłuchać się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(żeby)}
nasłuchać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(od,gen)}
nasłuchiwać: _: : imperf: subj{np(str)} + {cp(int)}
nasłuchiwać: _: : imperf: subj{np(str)} + {cp(jak)}
nasłuchiwać: _: : imperf: subj{np(str)} + {np(gen)}
naspędzać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
naspraszać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
naspraszać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)} + {xp(adl)}
nastać się: _: : perf: subj{np(str)} + {xp(locat)}
nastać: _: : perf: subj{np(str)} + {xp(locat)}
nastarczać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nastarczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
nastarczać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
nastarczyć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
nastarczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
nastarczyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
nastawać: _: : imperf: subj{np(str)} + {or}
nastawać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nastawać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
nastawać: _: : imperf: subj{np(str)} + {xp(locat)}
nastawiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
nastawiać się: _: : imperf: subj{np(str)} + {cp(że)}
nastawiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nastawiać: _: : perf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
nastawiać: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
nastawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nastawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nastawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nastawiać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(gen,_,'ucho',natr)}
nastawić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
nastawić się: _: : perf: subj{np(str)} + {cp(że)}
nastawić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nastawić: _: : perf: subj{np(str)} + controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
nastawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nastawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nastawić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(gen,_,'ucho',natr)}
nastąpić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
nastąpić: _: : perf: subj{ncp(str,że)}
nastąpić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nastąpić: _: : perf: subj{np(str)} + {prepnp(po,loc)}
nastąpić: _: : perf: subj{np(str)} + {xp(temp)}
następować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
następować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
następować: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
następować: _: : imperf: subj{np(str)} + {xp(temp)}
nastrajać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
nastrajać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastrajać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastrajać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nastrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {advp(misc)}
nastręczać się: _: : imperf: subj{np(str)} + {np(dat)}
nastręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
nastręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nastręczyć się: _: : perf: subj{np(str)} + {np(dat)}
nastręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
nastręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nastroić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
nastroić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastroić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastroić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastroić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nastroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {advp(misc)}
nastroszyć się: _: : perf: subj{np(str)} + {cp(że)}
nastroszyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
nastroszyć się: _: : perf: subj{np(str)} + {or}
nastroszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nastroszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
nasunąć się: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(na,acc)}
nasunąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasunąć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nasunąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
nasunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: _: : perf: subj{np(str)} + {np(gen)}
nasuwać się: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nasuwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
nasuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasycać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
nasycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
nasycić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
nasycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
nasyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nasyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nasyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
nasypać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nasypać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nasypywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nasypywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
naszyć się: _: : perf: subj{np(str)} + {np(gen)}
naszyć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
naszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
naszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
naszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
naszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
naścinać: _: : perf: subj{np(str)} + obj{np(part)}
naśladować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
naśladować: _: : imperf: subj{np(str)} + obj{np(str)}
naśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
naśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
naśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
naśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
natchnąć: _: : perf: {np(str)} + {cp(żeby)}
natchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
natchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
natężać się: _: : imperf: subj{np(str)}
natężać: _: : imperf: subj{np(str)} + obj{np(str)}
natężyć się: _: : perf: subj{np(str)}
natężyć: _: : perf: subj{np(str)} + obj{np(str)}
natknąć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby2)}
natłuc się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
natłuc się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
natłuc się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
natłuc się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
natłuc się: _: : perf: subj{np(str)} + {xp(locat)}
natłuc: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,_,'głowa',atr)}
natłuc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
natłuc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
natłuc: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
natłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',atr)}
natłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
natrafiać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrafić: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrzeć: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'ucho',natr)}
natrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
natrzeć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
natrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
natrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
natrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
natrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
natrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
natrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
natykać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby2)}
nauczać: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
nauczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {np(inst)}
nauczać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
nauczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nauczyć się: _: : perf: subj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {prepnp(od,gen); prepnp(z,gen)}
nauczyć się: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
nauczyć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
nauczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {np(inst)}
nauczyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
nauczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nauka: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)} + {possp}
nauka: : : : {possp} + {comprepnp(na temat)}
nauka: : : : {possp} + {comprepnp(w kwestii)}
nauka: : : : {possp} + {comprepnp(w sprawie)}
nauka: : : : {possp} + {cp(int)}
nauka: : : : {possp} + {cp(jakoby)}
nauka: : : : {possp} + {cp(że)}
nauka: : : : {possp} + {cp(żeby)}
nauka: : : : {possp} + {or}
nauka: : : : {possp} + {preplexnp(w,loc,sg,'dziedzina',atr)}
nauka: : : : {possp} + {preplexnp(w,loc,sg,'zakres',atr)}
nauka: : : : {possp} + {preplexnp(z,gen,sg,'dziedzina',atr)}
nauka: : : : {possp} + {preplexnp(z,gen,sg,'zakres',atr)}
nauka: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
nauka: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
nawadniać się: _: : imperf: subj{np(str)} + {np(inst)}
nawadniać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nawadniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nawalać się: _: : imperf: subj{np(str)} + {np(inst)}
nawalać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
nawalać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
nawalać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nawalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
nawalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
nawalać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
nawalać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
nawalić się: _: : perf: subj{np(str)} + {np(inst)}
nawalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nawalić się: _: : perf: subj{np(str)} + {xp(adl)}
nawalić: _: : perf: {np(gen)}
nawalić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nawalić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nawalić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nawalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
nawalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
nawalić: _: : perf: subj{np(str)} + {prepnp(z,inst)}
nawarstwiać się: _: : imperf: subj{np(str)} + {np(dat)}
nawarstwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
nawarstwiać się: _: : imperf: subj{np(str)} + {xp(locat)}
nawarstwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nawarstwić się: _: : perf: subj{np(str)} + {np(dat)}
nawarstwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nawarstwić się: _: : perf: subj{np(str)} + {xp(locat)}
nawarstwić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nawbijać się: _: : perf: subj{np(str)} + {np(gen)}
nawbijać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
nawbijać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
nawbijać: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',natr)}
nawbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',natr)}
nawbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
nawbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,acc)}
nawbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
nawbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
nawiać: _: : perf: {np(part)} + {xp(abl)} + {xp(adl)}
nawiać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nawiać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)} + {xp(adl)}
nawiać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
nawiać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
nawiązać się: _: : perf: subj{np(str)} + {np(gen)}
nawiązać się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
nawiązać: _: : perf: subj{np(str)} + {np(gen)}
nawiązać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
nawiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
nawiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
nawiązywać się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
nawiązywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
nawiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
nawiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
nawiedzać: _: : imperf: subj{np(str)} + obj{np(str)}
nawiedzić: _: : perf: subj{np(str)} + obj{np(str)}
nawiercać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
nawiercić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
nawiercić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
nawieszać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nawieszać się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
nawieszać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nawieszać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(locat)}
nawiewać: _: : imperf: {np(part)} + {xp(abl)} + {xp(adl)}
nawiewać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nawiewać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(abl)} + {xp(adl)}
nawiewać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
nawiewać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
nawijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nawijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
nawijać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
nawijać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
nawijać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
nawijać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
nawijać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
nawijać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
nawijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nawilgacać się: _: : imperf: subj{np(str)}
nawilgacać: _: : imperf: subj{np(str)} + obj{np(str)}
nawilżać się: _: : imperf: subj{np(str)} + {np(dat)}
nawilżać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nawilżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nawilżyć się: _: : perf: subj{np(str)} + {np(dat)}
nawilżyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
nawilżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nawinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nawinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
nawinąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nawinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nawlec się: _: : perf: {np(gen)} + {xp(abl)} + {xp(adl)}
nawlec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
nawlec: _: : perf: subj{np(str)} + obj{lexnp(str,_,'igła',atr)} + {np(dat)} + {np(inst)}
nawlec: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
nawlec: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)} + {xp(adl)}
nawlekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
nawlekać: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'igła',atr)} + {np(dat)} + {np(inst)}
nawlekać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
nawodnić się: _: : perf: subj{np(str)} + {np(inst)}
nawodnić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
nawodnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nawoływać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
nawoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nawoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
nawoływać: _: : imperf: subj{np(str)} + {or}
nawozić się: _: : perf: subj{np(str)} + {np(gen)}
nawozić: _: : perf: subj{np(str)} + {np(gen)}
nawozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nawracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
nawracać się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
nawracać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
nawracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
nawracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nawracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
nawracać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
nawrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
nawrócić się: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
nawrócić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
nawrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
nawrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nawrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
nawrócić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
nawykać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nawykać: _: : imperf: subj{np(str)} + {cp(że)}
nawykać: _: : imperf: subj{np(str)} + {cp(żeby)}
nawykać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
nawyknąć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
nawyknąć: _: : perf: subj{np(str)} + {cp(że)}
nawyknąć: _: : perf: subj{np(str)} + {cp(żeby)}
nawyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
nazbierać się: _: : perf: {np(dat)} + {xp(locat)}
nazbierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
nazbierać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
naznaczać się: _: : imperf: subj{np(str)} + {np(inst)}
naznaczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
naznaczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
naznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
naznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
naznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
naznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
naznaczyć się: _: : perf: subj{np(str)} + {np(inst)}
naznaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
naznaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
naznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
naznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
naznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
naznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nazwać: _: : perf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
nazwać: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
nazwać: _: : perf: subj,controller{np(str)} + controllee{np(nom)} + {refl}
nazwać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
nazwać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
nazwać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
nazwać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
nazwać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
nazwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
nazwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nazwać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
nazwozić się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nazwozić się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nazwozić się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nazwozić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nazwozić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nazwozić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nazywać się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
nazywać się: _: : imperf: subj,controller{np(str)} + controllee{np(nom)}
nazywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
nazywać: _: : imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
nazywać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
nazywać: _: : imperf: subj,controller{np(str)} + controllee{np(nom)} + {refl}
nazywać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
nazywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
nazywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
nazywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
nazywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
nazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nażąć się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
nażąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)}
negocjować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
negocjować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
negocjować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
negować: _: : imperf: subj{np(str)} + obj{cp(int)}
negować: _: : imperf: subj{np(str)} + obj{cp(że)}
negować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
neutralizować się: _: : imperf: subj{np(str)} + {xp(locat)}
neutralizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
neutralizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
neutralny: : : : {comprepnp(w kwestii)}
neutralny: : : : {comprepnp(w sprawie)}
neutralny: : : : {comprepnp(w stosunku do)}
neutralny: : : : {preplexnp(pod,inst,sg,'wzgląd',atr)}
neutralny: : : : {prepnp(co do,gen)}
neutralny: : : : {prepnp(dla,gen)}
neutralny: : : : {prepnp(w,loc)}
neutralny: : : : {prepnp(wobec,gen)}
neutralny: : : : {prepnp(względem,gen)}
neutralny: : : : {xp(mod)}
nękać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nic: : : : {cp(że)}
nic: : : : {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że)}
nic: : : : {np(dat)} + {prepnp(po,loc); prepncp(po,loc,że)}
nic: : : : {np(dat)} + {prepnp(z,gen); prepncp(z,gen,że)}
nieadekwatny: : : : {comprepnp(w stosunku do)}
nieadekwatny: : : : {prepnp(dla,gen); prepnp(do,gen); prepncp(do,gen,int)}
nieadekwatny: : : : {prepnp(wobec,gen)}
nieadekwatny: : : : {prepnp(względem,gen)}
nieadekwatny: : : : {prepnp(z,inst); prepncp(z,inst,int)}
niebezpieczeństwo: : : : {np(gen); ncp(gen,że)} + {prepnp(dla,gen)}
niebezpieczeństwo: : : : {prepnp(dla,gen)} + {cp(że)}
niebezpieczeństwo: : : : {prepnp(wobec,gen)}
niechęć: : : : {np(dat)}
niechęć: : : : {possp} + {comprepnp(co do); prepncp(co do,gen,int); prepncp(co do,gen,żeby)}
niechęć: : : : {possp} + {comprepnp(w kwestii)}
niechęć: : : : {possp} + {comprepnp(w sprawie)}
niechęć: : : : {possp} + {comprepnp(w stosunku do)}
niechęć: : : : {possp} + {cp(żeby)}
niechęć: : : : {possp} + {prepnp(dla,gen)}
niechęć: : : : {possp} + {prepnp(do,gen)} + {cp(że)}
niechęć: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
niechęć: : : : {possp} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
niechęć: : : : {possp} + {prepnp(przeciw,dat)}
niechęć: : : : {possp} + {prepnp(wobec,gen); prepncp(wobec,gen,int); prepncp(wobec,gen,że); prepncp(wobec,gen,żeby)}
niechęć: : : : {possp} + {prepnp(względem,gen)}
niechęć: : : : {prepnp(między,inst)}
niechętny: : : : {comprepnp(w stosunku do)}
niechętny: : : : {cp(żeby)}
niechętny: : : : {np(dat); ncp(dat,żeby)}
niechętny: : : : {prepnp(co do,gen)}
niechętny: : : : {prepnp(dla,gen)}
niechętny: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
niechętny: : : : {prepnp(ku,dat)}
niechętny: : : : {prepnp(na,acc)}
niechętny: : : : {prepnp(wobec,gen)}
niechętny: : : : {prepnp(względem,gen)}
niecierpliwić się: _: : imperf: subj{np(str)} + {cp(int)}
niecierpliwić się: _: : imperf: subj{np(str)} + {cp(że)}
niecierpliwić się: _: : imperf: subj{np(str)} + {cp(żeby)}
niecierpliwić się: _: : imperf: subj{np(str)} + {np(inst)}
niecierpliwić się: _: : imperf: subj{np(str)} + {or}
niecierpliwić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
niecierpliwić: _: : imperf: subj{cp(że)} + {np(str)}
niecierpliwić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
nieczuły: : : : {comprepnp(w stosunku do)}
nieczuły: : : : {prepnp(dla,gen)}
nieczuły: : : : {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
nieczuły: : : : {prepnp(względem,gen)}
niedaleki: : : : {np(dat)}
niedaleki: : : : {prepnp(dla,gen)}
niedaleki: : : : {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,żeby)}
niedbały: : : : {prepnp(na,acc)}
niedbały: : : : {prepnp(o,acc)}
niedobry: : : : {prepnp(dla,gen)}
niedobry: : : : {prepnp(do,gen)}
niedobry: : : : {prepnp(na,acc)}
niedobry: : : : {prepnp(w,loc)}
niedobry: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
niedobry: : pred: : {prepnp(dla,gen)} + {cp(jak)}
niedobry: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
niedobry: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
niedobry: : pred: : {prepnp(dla,gen)} + {cp(że)}
niedobry: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
niedojrzały: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
niedojrzały: : : : {prepnp(na,acc); prepncp(na,acc,żeby)}
niedojrzały: : pred: : {cp(gdy)}
niedojrzały: : pred: : {cp(jak)}
niedojrzały: : pred: : {cp(jeśli)}
niedojrzały: : pred: : {cp(kiedy)}
niedojrzały: : pred: : {cp(żeby)}
niedołężnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
niedołężnieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
niedomagać: _: : imperf: subj{np(str)} + {advp(misc)}
niedomagać: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
niedomagać: _: : imperf: subj{np(str)} + {np(dat)}
niedomagać: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'zdrowie',natr)}
niedomagać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
niedopuszczalny: : : : {prepnp(co do,gen)}
niedopuszczalny: : : : {prepnp(dla,gen)}
niedopuszczalny: : : : {prepnp(w,loc)}
niedopuszczalny: : : : {xp(locat)}
niedopuszczalny: : : : {xp(temp)}
niedopuszczalny: : pred: : {cp(gdy)}
niedopuszczalny: : pred: : {cp(int)}
niedopuszczalny: : pred: : {cp(jak)}
niedopuszczalny: : pred: : {cp(jeśli)}
niedopuszczalny: : pred: : {cp(kiedy)}
niedopuszczalny: : pred: : {cp(że)}
niedopuszczalny: : pred: : {cp(żeby)}
niedorzeczny: : : : {prepnp(dla,gen)}
niedorzeczny: : : : {prepnp(w,loc)}
niedorzeczny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
niedorzeczny: : pred: : {prepnp(dla,gen)} + {cp(int)}
niedorzeczny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
niedorzeczny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
niedorzeczny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
niedorzeczny: : pred: : {prepnp(dla,gen)} + {cp(że)}
niedorzeczny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
niedosłyszeć: _: : imperf: subj{np(str)}
niedostępny: : : : {np(dat)} + {xp(locat)} + {xp(perl)}
niedostępny: : : : {preplexnp(dla,gen,_,'kieszeń',atr)}
niedostępny: : : : {prepnp(dla,gen); xp(locat); xp(perl)}
niedostępny: : : : {prepnp(dla,gen)} + {xp(locat)} + {xp(perl)}
niedostępny: : : : {prepnp(do,gen)}
niedowidzieć: _: : imperf: subj{np(str)}
niefortunny: : : : {prepnp(dla,gen)}
niefortunny: : : : {prepnp(w,loc)}
niefortunny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
niefortunny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
niefortunny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
niefortunny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
niefortunny: : pred: : {prepnp(dla,gen)} + {cp(że)}
niefortunny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
niegodny: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)}
niegodny: : pred: : {cp(gdy)}
niegodny: : pred: : {cp(jak)}
niegodny: : pred: : {cp(jeśli)}
niegodny: : pred: : {cp(kiedy)}
niegodny: : pred: : {cp(że)}
niegodny: : pred: : {cp(żeby)}
nieistotny: : : : {comprepnp(w stosunku do)} + {advp(misc)}
nieistotny: : : : {prepnp(dla,gen)} + {advp(misc)}
nieistotny: : : : {xp(locat)}
nieistotny: : pred: : {prepnp(dla,gen)} + {cp(int)}
nieistotny: : pred: : {prepnp(dla,gen)} + {cp(że)}
nieistotny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
niekompetentny: : : : {cp(żeby)}
niekompetentny: : : : {prepnp(dla,gen)}
niekompetentny: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
niekompetentny: : : : {prepnp(w,loc); prepncp(w,loc,żeby)}
niekonsekwentny: : : : {comprepnp(co do)}
niekonsekwentny: : : : {comprepnp(w kwestii)}
niekonsekwentny: : : : {comprepnp(w sprawie)}
niekonsekwentny: : : : {comprepnp(w stosunku do)}
niekonsekwentny: : : : {prepnp(w,loc)}
niekonsekwentny: : : : {prepnp(wobec,gen)}
niekonsekwentny: : : : {prepnp(względem,gen)}
nielojalny: : : : {np(dat)}
nielojalny: : : : {prepnp(wobec,gen); comprepnp(w stosunku do)}
nielojalny: : : : {prepnp(względem,gen)}
nienawidzić: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nienawidzić: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,gdy); ncp(gen,int); ncp(gen,jak); ncp(gen,kiedy); ncp(gen,że)}
nienawidzić: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nienawidzić: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
nienawistny: : : : {np(dat)}
nienawistny: : : : {prepnp(dla,gen)}
nienawistny: : : : {prepnp(do,gen); comprepnp(w stosunku do)}
nienawistny: : : : {prepnp(wobec,gen)}
nienawistny: : : : {prepnp(względem,gen)}
nienawiść: : : : {np(gen); ncp(gen,że)} + {possp} + {comprepnp(z powodu)}
nienawiść: : : : {possp} + {comprepnp(w stosunku do)} + {comprepnp(z powodu)}
nienawiść: : : : {possp} + {comprepnp(w stosunku do)} + {preplexnp(na,loc,sg,'tło',atr)}
nienawiść: : : : {possp} + {prepnp(dla,gen)} + {comprepnp(z powodu)}
nienawiść: : : : {possp} + {prepnp(do,gen)} + {preplexnp(na,loc,sg,'tło',atr)}
nienawiść: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,że)} + {comprepnp(z powodu)}
nienawiść: : : : {possp} + {prepnp(wobec,gen); prepncp(wobec,gen,że)} + {comprepnp(z powodu)}
nienawiść: : : : {possp} + {prepnp(względem,gen)} + {comprepnp(z powodu)}
nienawiść: : : : {prepnp(między,inst)} + {comprepnp(z powodu)}
nieobcy: : : : {np(dat)}
nieobcy: : : : {prepnp(dla,gen)}
nieobcy: : pred: : {np(dat)} + {cp(int)}
nieobcy: : pred: : {np(dat)} + {cp(że)}
nieodłączny: : : : {prepnp(dla,gen)}
nieodłączny: : : : {prepnp(od,gen)}
nieodłączny: : : : {prepnp(w,loc)}
nieodzowny: : : : {np(dat)} + {prepnp(do,gen); prepnp(w,loc); prepncp(do,gen,żeby)}
nieodzowny: : : : {np(dat)} + {prepnp(przy,loc)}
nieodzowny: : : : {prepnp(dla,gen)} + {prepnp(do,gen); prepnp(w,loc); prepncp(do,gen,żeby)}
nieodzowny: : pred: : {prepnp(dla,gen)} + {cp(gdy); cp(jeśli)}
nieodzowny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
nieodzowny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
nieodzowny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
niepodobny: : : : {np(dat)} + {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)}
niepodobny: : : : {prepnp(do,gen)} + {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)}
niepodobny: : pred: : {cp(żeby)}
niepodzielny: : : : {advp(misc)}
niepodzielny: : : : {prepnp(na,acc)}
niepodzielny: : : : {prepnp(przez,acc)}
niepokoić się: _: : imperf: subj{np(str)} + {cp(int)}
niepokoić się: _: : imperf: subj{np(str)} + {cp(że)}
niepokoić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
niepokoić się: _: : imperf: subj{np(str)} + {or}
niepokoić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
niepokoić: _: : imperf: subj{cp(gdy)} + {np(str)}
niepokoić: _: : imperf: subj{cp(jak)} + {np(str)}
niepokoić: _: : imperf: subj{cp(jeśli)} + {np(str)}
niepokoić: _: : imperf: subj{cp(kiedy)} + {np(str)}
niepokoić: _: : imperf: subj{cp(że)} + {np(str)}
niepokoić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
niepokoić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
niepokój: : : : {np(gen)} + {possp}
niepokój: : : : {possp} + {comprepnp(w kwestii)}
niepokój: : : : {possp} + {comprepnp(w sprawie)}
niepokój: : : : {possp} + {comprepnp(w stosunku do)}
niepokój: : : : {possp} + {comprepnp(z powodu)}
niepokój: : : : {possp} + {cp(gdy)}
niepokój: : : : {possp} + {cp(int)}
niepokój: : : : {possp} + {cp(kiedy)}
niepokój: : : : {possp} + {cp(że)}
niepokój: : : : {possp} + {cp(żeby)}
niepokój: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
niepokój: : : : {possp} + {prepnp(o,acc); prepnp(przed,inst); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
niepokój: : : : {possp} + {prepnp(wobec,gen)}
niepokój: : : : {possp} + {prepnp(względem,gen)}
niepokój: : : : {prepnp(wokół,gen)} + {xp(locat)}
nieporadny: : : : {comprepnp(w kwestii)}
nieporadny: : : : {comprepnp(w sprawie)}
nieporadny: : : : {comprepnp(w stosunku do)}
nieporadny: : : : {prepnp(w,loc)}
nieporadny: : : : {prepnp(wobec,gen)}
nieporadny: : : : {xp(locat)}
nieporadny: : : : {xp(mod)}
nieporównywalny: : : : {comprepnp(w stosunku do)}
nieporównywalny: : : : {prepnp(do,gen); prepncp(do,gen,int)}
nieporównywalny: : : : {prepnp(wobec,gen)}
nieporównywalny: : : : {prepnp(względem,gen)}
nieporównywalny: : : : {prepnp(z,inst); prepncp(z,inst,int)}
nieprawda: : : : {comprepnp(na temat)}
nieprawda: : : : {comprepnp(w kwestii)}
nieprawda: : : : {comprepnp(w sprawie)}
nieprawda: : : : {cp(jakoby); cp(żeby)}
nieprawda: : : : {cp(że)}
nieprawda: : : : {or}
nieprawda: : : : {possp}
nieprawda: : : : {prepnp(co do,gen)}
nieprawda: : : : {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)}
nieprawda: : : : {prepnp(wobec,gen)}
nieprawda: : : : {prepnp(względem,gen)}
nieproporcjonalny: : : : {comprepnp(co do)}
nieproporcjonalny: : : : {comprepnp(w stosunku do)}
nieproporcjonalny: : : : {prepnp(do,gen)}
nieproporcjonalny: : : : {prepnp(wobec,gen)}
nieproporcjonalny: : : : {prepnp(względem,gen)}
nieprzemakalny: : : : {prepnp(dla,gen)}
nieprzemakalny: : : : {prepnp(na,acc)}
nieprzemakalny: : : : {prepnp(wobec,gen)}
nieprzychylny: : : : {comprepnp(w stosunku do)}
nieprzychylny: : : : {np(dat); ncp(dat,że)}
nieprzychylny: : : : {prepnp(co do,gen)}
nieprzychylny: : : : {prepnp(dla,gen)}
nieprzychylny: : : : {prepnp(do,gen)}
nieprzychylny: : : : {prepnp(ku,dat)}
nieprzychylny: : : : {prepnp(na,acc)}
nieprzychylny: : : : {prepnp(wobec,gen)}
nieprzychylny: : : : {prepnp(względem,gen)}
nieprzyjazny: : : : {comprepnp(w stosunku do)}
nieprzyjazny: : : : {np(dat)}
nieprzyjazny: : : : {prepnp(dla,gen)}
nieprzyjazny: : : : {prepnp(do,gen)}
nieprzyjazny: : : : {prepnp(ku,dat)}
nieprzyjazny: : : : {prepnp(wobec,gen)}
nieprzyjazny: : : : {prepnp(względem,gen)}
nierówny: : : : {comprepnp(w stosunku do)}
nierówny: : : : {np(dat)} + {advp(misc)}
nierówny: : : : {np(dat)} + {comprepnp(co do)}
nierówny: : : : {np(dat)} + {np(inst)}
nierówny: : : : {prepnp(w,loc)}
nierówny: : : : {prepnp(wobec,gen)}
nierówny: : : : {prepnp(względem,gen)}
niespójny: : : : {comprepnp(co do)}
niespójny: : : : {comprepnp(w kwestii)}
niespójny: : : : {comprepnp(w stosunku do)}
niespójny: : : : {prepnp(w,loc)} + {advp(misc)}
niespójny: : : : {prepnp(z,inst)} + {advp(misc)}
nieszczęście: : : : {possp} + {comprepnp(z powodu)}
nieszczęście: : : : {possp} + {cp(gdy)}
nieszczęście: : : : {possp} + {cp(że)}
nieść się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
nieść się: _: : imperf: subj{np(str)} + {or}
nieść się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
nieść się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nieść się: _: : imperf: subj{np(str)} + {xp(perl)}
nieść: _: : imperf: {np(inst)} + {xp(abl)}
nieść: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
nieść: _: : imperf: {np(str)} + {xp(perl)}
nieść: _: : imperf: subj{np(str)} + {cp(że)}
nieść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nieść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
nieść: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
nieść: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nieść: _: : imperf: subj{np(str)} + {xp(locat)} + {or}
nieufny: : : : {comprepnp(w stosunku do)}
nieufny: : : : {preplexnp(z,gen,sg,'natura',natr)}
nieufny: : : : {prepnp(co do,gen); prepncp(co do,gen,int)}
nieufny: : : : {prepnp(do,gen)}
nieufny: : : : {prepnp(wobec,gen)}
nieufny: : : : {prepnp(względem,gen)}
niewidzialny: : : : {lexnp(inst,sg,'oko',atr)}
niewidzialny: : : : {prepnp(dla,gen)}
niknąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
niknąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
niknąć: _: : imperf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',natr)}
niknąć: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
niszczeć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
niszczeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
niszczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
niszczyć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
niszczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
niweczyć: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
niweczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
niwelować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nocować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nocować: _: : imperf: subj{np(str)} + {xp(locat)} + {preplexnp(na,acc,sg,'walet',natr)}
nominować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nominować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nominować: _: : _: subj{np(str)} + {prepnp(do,gen)} + {refl}
nominować: _: : _: subj{np(str)} + {prepnp(na,acc)} + {refl}
normować się: _: : imperf: subj{np(str)} + {np(dat)}
normować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nosić się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
nosić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
nosić: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
nosić: _: : imperf: {np(str)} + {xp(perl)}
nosić: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
nosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
notować: _: : imperf: subj{np(str)} + {cp(żeby2)}
notować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
notować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(inst)} + {xp(locat)}
notować: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {xp(locat)}
notować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(inst)} + {xp(locat)}
notować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
nowelizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nucić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
nucić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
nucić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
nucić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nudzić się: _: : imperf: subj,controllee{infp(imperf)} + controller{np(dat)}
nudzić się: _: : imperf: subj{cp(że)} + {np(dat)}
nudzić się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
nudzić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
nudzić: _: : imperf: {np(str)}
nudzić: _: : imperf: subj{cp(gdy)} + {np(str)}
nudzić: _: : imperf: subj{cp(jak)} + {np(str)}
nudzić: _: : imperf: subj{cp(kiedy)} + {np(str)}
nudzić: _: : imperf: subj{cp(że)} + {np(str)}
nudzić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
nudzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
nudzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
nudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
nudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
nudzić: _: : imperf: subj{np(str)} + {or}
numerować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
numerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nurt: : : : {np(gen)} + {possp} + {prepnp(w,loc)}
nurt: : : : {prepnp(o,acc)}
nurtować: _: : imperf: subj{cp(int)} + {np(str)}
nurtować: _: : imperf: subj{cp(żeby)} + {np(str)}
nurtować: _: : imperf: subj{cp(że)} + {np(str)}
nurtować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
nurtować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
obalać się: _: : imperf: subj{np(str)} + {xp(adl)}
obalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
obalić się: _: : perf: subj{np(str)} + {xp(adl)}
obalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
obandażować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obandażować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obarczać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
obarczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
obarczyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
obarczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
obawa: : : : {np(gen)} + {possp}
obawa: : : : {possp} + {comprepnp(w kwestii)}
obawa: : : : {possp} + {comprepnp(w sprawie)}
obawa: : : : {possp} + {comprepnp(w stosunku do)}
obawa: : : : {possp} + {comprepnp(z powodu)}
obawa: : : : {possp} + {cp(gdy)}
obawa: : : : {possp} + {cp(int)}
obawa: : : : {possp} + {cp(jakoby)}
obawa: : : : {possp} + {cp(kiedy)}
obawa: : : : {possp} + {cp(że)}
obawa: : : : {possp} + {cp(żeby)}
obawa: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
obawa: : : : {possp} + {prepnp(o,acc); prepnp(przed,inst); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
obawa: : : : {possp} + {prepnp(wobec,gen)}
obawa: : : : {possp} + {prepnp(względem,gen)}
obawiać się: _: : imperf: subj,controller{np(str)} + controllee{np(gen); cp(że); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); infp(_)}
obawiać się: _: : imperf: subj{np(str)} + {cp(int)}
obawiać się: _: : imperf: subj{np(str)} + {cp(żeby)}
obawiać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); cp(że); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
obchodzić się: _: : imperf: {prepnp(bez,gen)}
obchodzić się: _: : imperf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
obchodzić się: _: : imperf: subj{np(str)} + {np(inst)}
obchodzić się: _: : imperf: subj{np(str)} + {prepnp(bez,gen)}
obchodzić: _: : imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(str)}
obchodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
obchodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
obciąć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
obciąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
obciąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
obciąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
obciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
obciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obciągać się: _: : imperf: subj{np(str)} + {np(inst)}
obciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
obciągnąć się: _: : perf: subj{np(str)} + {np(inst)}
obciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
obciążać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
obciążać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
obciążać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
obciążyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
obciążyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
obciążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
obciec: _: : perf: subj{np(str)} + {np(inst)}
obciec: _: : perf: subj{np(str)} + {prepnp(z,gen)}
obciekać: _: : imperf: subj{np(str)} + {np(inst)}
obciekać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
obcierać się: _: : imperf: subj{np(str)} + {np(dat)}
obcierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
obcierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obcinać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
obcinać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
obcinać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
obcinać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
obcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
obcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obciosać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obciosać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
obciosać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obciosywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obciosywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
obciosywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obcować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
obcy: : : : {comprepnp(w stosunku do)}
obcy: : : : {np(dat)}
obcy: : : : {prepnp(dla,gen)}
obcy: : : : {prepnp(wobec,gen)}
obcy: : : : {prepnp(względem,gen)}
obcy: : pred: : {np(dat)} + {cp(że)}
obczytać się: _: : perf: subj{np(str)} + {np(gen)}
obczytać się: _: : perf: subj{np(str)} + {np(inst)}
obczytać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
obczytać: _: : perf: subj{np(str)} + obj{np(str)}
obdarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdzierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obdzierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obedrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obedrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obejmować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
obejmować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
obejmować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
obejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
obejrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
obejrzeć się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
obejrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w roli)}
obejrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
obejrzeć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
obejrzeć: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
obejść się: _: : perf: {prepnp(bez,gen)}
obejść się: _: : perf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
obejść się: _: : perf: subj{np(str)} + {np(inst)}
obejść się: _: : perf: subj{np(str)} + {prepnp(bez,gen)}
obejść: _: : perf: subj{cp(że)} + {np(str)}
obejść: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)}
oberwać się: _: : perf: {np(dat)} + {prepnp(od,gen)} + {cp(że)}
oberwać się: _: : perf: {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oberwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
oberwać się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
oberwać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
oberwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oberwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(w,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oberwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
oberwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
oberwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oberwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oberżnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oberżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oberżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oberżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
oberżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
obeschnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obetkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obetonować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obetrzeć się: _: : perf: subj{np(str)} + {np(dat)}
obetrzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
obetrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obeznać się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
obeznać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
obezwładniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obezwładniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obezwładnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obezwładnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obfitować: _: : imperf: subj{np(str)} + {np(inst)}
obfitować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
obgotować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
obgotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obgotowywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
obgotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obić się: _: : perf: subj{cp(żeby2)} + {np(dat)} + {preplexnp(o,acc,pl,'ucho',natr)}
obić się: _: : perf: subj{np(str); cp(int); cp(że); ncp(str,że)} + {np(dat)} + {preplexnp(o,acc,pl,'ucho',natr)}
obić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
obić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
obić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obiec: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obiec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
obiecać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
obiecać: _: : perf: subj{np(str)} + {np(dat)} + {or}
obiecać: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
obiecywać: _: : imperf: subj,controller{np(str)} + obj,controllee{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)}
obiecywać: _: : imperf: subj{np(str)} + obj{or} + {np(dat)}
obiegać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obiegać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
obierać się: _: : imperf: subj{np(str)} + {np(dat)}
obierać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
obierać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
obierać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
obierać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
obierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obijać się: _: : imperf: subj{cp(żeby2)} + {np(dat)} + {preplexnp(o,acc,pl,'ucho',natr)}
obijać się: _: : imperf: subj{np(str); cp(int); cp(że); ncp(str,że)} + {np(dat)} + {preplexnp(o,acc,pl,'ucho',natr)}
obijać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
obijać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
obijać się: _: : imperf: subj{np(str)} + {xp(locat)}
obijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
obijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
objadać się: _: : imperf: subj{np(str)} + {np(inst)}
objadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
objaśniać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
objaśniać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
objaśniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
objaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
objaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
objaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
objaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
objaśniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
objaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
objaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
objaśnić: _: : perf: subj{np(str)} + {np(dat)} + {or}
objaśnić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
objaśnić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
objaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
objaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
objaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
objaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
objaśnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
objaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
objaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
objawiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
objawiać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
objawiać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
objawiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
objawiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
objawiać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
objawiać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
objawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
objawić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
objawić się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
objawić się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
objawić: _: : perf: subj{np(str)} + {np(dat)} + {or}
objawić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
objawić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
objawić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
objawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
objąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
objąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
objąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
objąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
objąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
objechać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
objechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc)}
objechać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
objeść się: _: : perf: subj{np(str)} + {np(gen)}
objeść się: _: : perf: subj{np(str)} + {np(inst)}
objeść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
objeździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc)}
objeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
objeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc)}
objeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
objuczać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
objuczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
objuczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
objuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obkładać się: _: : imperf: subj{np(str)} + {np(inst)}
obkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obkrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obkrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obkroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obkroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obkuć się: _: : perf: subj{np(str)} + {np(gen)}
obkuć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
obkuć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
obkuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obkuć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'blacha',natr)}
obkuć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pamięć',natr)}
obkuwać się: _: : imperf: subj{np(str)} + {np(gen)}
obkuwać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
obkuwać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
obkuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obkuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'blacha',natr)}
obkuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pamięć',natr)}
oblać się: _: : perf: subj{np(str)} + {np(inst)}
oblać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oblać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
oblać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oblać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obladzać się: _: : imperf: subj{np(str)}
obladzać: _: : imperf: subj{E} + obj{np(str)} + {np(dat)}
obladzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
oblamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblegać: _: : imperf: subj{np(str)} + obj{np(str)}
oblepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
oblepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
oblepiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oblepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblepić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
oblepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
oblepić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oblepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblewać się: _: : imperf: subj{np(str)} + {np(inst)}
oblewać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oblewać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
oblewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oblewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obliczać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
obliczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
obliczać: _: : imperf: subj{np(str)} + obj{cp(int)}
obliczać: _: : imperf: subj{np(str)} + obj{cp(że)}
obliczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obliczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
obliczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
obliczyć: _: : perf: subj{np(str)} + obj{cp(int)}
obliczyć: _: : perf: subj{np(str)} + obj{cp(że)}
obliczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obligować: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(w,loc)} + {refl}
obligować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)} + {prepnp(w,loc)}
obligować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
obligować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
obligować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(że)}
obligować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
obligować: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)} + {refl}
obligować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)} + {refl}
obligować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)} + {refl}
oblodzić się: _: : perf: subj{np(str)}
oblodzić: _: : perf: subj{E} + obj{np(str)} + {np(dat)}
oblodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obluzować się: _: : perf: subj{np(str)} + {np(dat)}
obluzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obluzowywać się: _: : imperf: subj{np(str)} + {np(dat)}
obluzowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obładować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obładować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obładowywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obłaskawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obłaskawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obławiać się: _: : imperf: subj{np(str)} + {np(inst)}
obławiać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
obławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obłowić się: _: : perf: subj{np(str)} + {np(inst)}
obłowić się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
obłowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obłożyć się: _: : perf: subj{np(str)} + {np(inst)}
obłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obłupać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obłupać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
obłupać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
obłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
obłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
obłupywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obłupywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
obłupywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
obłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
obłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
obmacać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc); xp(locat)} + {refl}
obmacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obmacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
obmacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); xp(locat)}
obmacywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
obmacywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc); xp(locat)} + {refl}
obmacywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obmacywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
obmacywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); xp(locat)}
obmiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obmiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
obmierzać: _: : imperf: subj,controllee{infp(imperf)} + controller{np(dat)}
obmierzać: _: : imperf: subj{cp(int)} + {np(dat)}
obmierzać: _: : imperf: subj{cp(że)} + {np(dat)}
obmierzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
obmierzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
obmierzać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
obmierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
obmierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
obmierzić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
obmierzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
obmierznąć: _: : perf: subj,controllee{infp(imperf)} + controller{np(dat)}
obmierznąć: _: : perf: subj{cp(int)} + {np(dat)}
obmierznąć: _: : perf: subj{cp(że)} + {np(dat)}
obmierznąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
obmierzyć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
obmierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
obmieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obmieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
obmurować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obmurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obmyślać: _: : imperf: subj{np(str)} + {cp(int)}
obmyślać: _: : imperf: subj{np(str)} + obj{np(str)}
obmyślić: _: : perf: subj{np(str)} + {cp(int)}
obmyślić: _: : perf: subj{np(str)} + obj{np(str)}
obnażać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
obnażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
obnażyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
obnażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
obnieść się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
obnieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
obniżać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
obniżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obniżyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
obniżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obnosić się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
obnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
obojętnieć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
obojętnieć: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
obojętnieć: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
oborać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
oborywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
obostrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obowiązywać: _: : imperf: subj{np(str)} + {np(str)}
obowiązywać: _: : imperf: subj{np(str)} + {xp(dur)}
obozować: _: : imperf: subj{np(str)} + {xp(locat)}
obóz: : : : {np(gen); adjp(agr)} + {possp} + {prepnp(dla,gen)}
obóz: : : : {possp} + {comprepnp(na rzecz)}
obóz: : : : {possp} + {prepnp(dla,gen)} + {prepnp(z,gen)}
obóz: : : : {prepnp(wokół,gen)}
obrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obrabować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obrabować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obracać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
obracać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
obracać się: _: : imperf: subj{np(str)} + {prepadjp(na,acc)}
obracać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
obracać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
obracać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
obracać się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
obracać się: _: : imperf: subj{np(str)} + {xp(locat)}
obracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
obracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
obracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
obrać: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
obrać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
obrać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
obrać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
obrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obradować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); comprepnp(w sprawie); prepncp(nad,inst,int)}
obradować: _: : imperf: subj{np(str)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int)}
obrastać: _: : imperf: subj{np(str)} + {np(inst)}
obrastać: _: : imperf: subj{np(str)} + obj{np(str)}
obrastać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
obrazić się: _: : perf: subj{np(str)} + {or}
obrazić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
obrazić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
obrazić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
obrazić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
obrazić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obrazić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
obrazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
obrazować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
obrazować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
obrazować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
obrazować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
obrażać się: _: : imperf: subj{np(str)} + {or}
obrażać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
obrażać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
obrażać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
obrażać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
obrażać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obrażać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
obrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
obrączkować: _: : imperf: subj{np(str)} + obj{np(str)}
obrobić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
obrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obronić się: _: : perf: subj{np(str)} + {cp(że)}
obronić się: _: : perf: subj{np(str)} + {np(dat)}
obronić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
obronić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
obronić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
obronić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
obronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obronić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
obronić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
obrosnąć: _: : perf: subj{np(str)} + {np(inst)}
obrosnąć: _: : perf: subj{np(str)} + obj{np(str)}
obrosnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
obrócić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
obrócić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
obrócić się: _: : perf: subj{np(str)} + {prepadjp(na,acc)}
obrócić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
obrócić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
obrócić się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
obrócić się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
obrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
obrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
obrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
obruszać się: _: : imperf: subj{np(str)} + {np(inst)}
obruszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
obruszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
obruszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
obruszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
obruszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
obruszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
obruszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obruszać: _: : imperf: subj{cp(gdy)} + {np(str)}
obruszać: _: : imperf: subj{cp(int)} + {np(str)}
obruszać: _: : imperf: subj{cp(jak)} + {np(str)}
obruszać: _: : imperf: subj{cp(jeśli)} + {np(str)}
obruszać: _: : imperf: subj{cp(kiedy)} + {np(str)}
obruszać: _: : imperf: subj{cp(że)} + {np(str)}
obruszać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
obruszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
obruszyć się: _: : perf: subj{np(str)} + {np(inst)}
obruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
obruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
obruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
obruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
obruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
obruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
obruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obruszyć: _: : perf: subj{cp(gdy)} + {np(str)}
obruszyć: _: : perf: subj{cp(int)} + {np(str)}
obruszyć: _: : perf: subj{cp(jak)} + {np(str)}
obruszyć: _: : perf: subj{cp(jeśli)} + {np(str)}
obruszyć: _: : perf: subj{cp(kiedy)} + {np(str)}
obruszyć: _: : perf: subj{cp(że)} + {np(str)}
obruszyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
obruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
obrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
obrysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
obrywać się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {cp(że)}
obrywać się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obrywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
obrywać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
obrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
obrywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obrywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(w,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obrywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
obrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
obrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obrzezać się: _: : perf: subj{np(str)}
obrzezać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obrzezać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrzmieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
obrzmieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obrzmiewać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
obrzmiewać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obsadzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
obsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obsadzać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
obsadzać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
obsadzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
obsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obsadzić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
obsadzić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
obserwować: _: : imperf: subj{np(str)} + {cp(int)}
obserwować: _: : imperf: subj{np(str)} + {cp(jak)}
obserwować: _: : imperf: subj{np(str)} + {cp(że)}
obserwować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obsiać się: _: : perf: subj{np(str)} + {xp(locat)}
obsiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsiąść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
obsiewać się: _: : imperf: subj{np(str)} + {xp(locat)}
obsiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obskubać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obskubać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
obskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obskubywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
obsługiwać: _: : imperf: subj{np(str)} + obj{np(str)}
obsługiwać: _: : imperf: subj{np(str)} + {refl}
obsłużyć: _: : perf: subj{np(str)} + obj{np(str)}
obsłużyć: _: : perf: subj{np(str)} + {refl}
obstalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
obstalowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
obstawać: _: : imperf: subj{np(str)} + {cp(że)}
obstawać: _: : imperf: subj{np(str)} + {cp(żeby)}
obstawać: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)}
obstawać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)}
obstawiać się: _: : imperf: subj{np(str)} + {np(inst)}
obstawiać: _: : imperf: subj{np(str)} + {cp(int)}
obstawiać: _: : imperf: subj{np(str)} + {cp(że)}
obstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
obstawiać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
obstawić: _: : perf: subj{np(str)} + {cp(int)}
obstawić: _: : perf: subj{np(str)} + {cp(że)}
obstawić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obstawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
obstawić: _: : perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
obsunąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
obsunąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
obsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
obsuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
obsuwać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
obsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
obsychać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obsypać się: _: : perf: subj{np(str)} + {xp(abl)}
obsypać się: _: : perf: subj{np(str)} + {xp(adl)}
obsypać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obsypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsypywać się: _: : imperf: subj{np(str)} + {xp(abl)}
obsypywać się: _: : imperf: subj{np(str)} + {xp(adl)}
obsypywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
obszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
obszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obtulać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obtulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obtulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obtulać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obtulić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obtulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obtulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
obtulić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obtykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
obuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obuć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obudować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obudować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obudowywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obudowywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obudzić się: _: : perf: subj,controller{np(str)} + controllee{adjp(inst)}
obudzić się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
obudzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
obudzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
obudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
obudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
obumierać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
obumierać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
obumierać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
obumrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
obumrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
obumrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
oburzać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
oburzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
oburzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
oburzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
oburzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {or}
oburzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oburzać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
oburzać: _: : imperf: subj{cp(gdy)} + {np(str)}
oburzać: _: : imperf: subj{cp(jak)} + {np(str)}
oburzać: _: : imperf: subj{cp(jeśli)} + {np(str)}
oburzać: _: : imperf: subj{cp(kiedy)} + {np(str)}
oburzać: _: : imperf: subj{cp(że)} + {np(str)}
oburzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
oburzać: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
oburzyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
oburzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
oburzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
oburzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
oburzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {or}
oburzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oburzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
oburzyć: _: : perf: subj{cp(gdy)} + {np(str)}
oburzyć: _: : perf: subj{cp(jak)} + {np(str)}
oburzyć: _: : perf: subj{cp(jeśli)} + {np(str)}
oburzyć: _: : perf: subj{cp(kiedy)} + {np(str)}
oburzyć: _: : perf: subj{cp(że)} + {np(str)}
oburzyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
oburzyć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
obuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
obuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obuwać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obwiesić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
obwiesić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obwieszać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
obwieszać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obwieszczać: _: : imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
obwieszczać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
obwieszczać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
obwieszczać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
obwieszczać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
obwieszczać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
obwieszczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
obwieszczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
obwieszczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
obwieszczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
obwieszczać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
obwieszczać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
obwieszczać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
obwieszczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
obwieścić: _: : perf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
obwieścić: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
obwieścić: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
obwieścić: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
obwieścić: _: : perf: subj{np(str)} + {np(dat)} + {or}
obwieścić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
obwieścić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
obwieścić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
obwieścić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
obwieścić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
obwieścić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
obwieścić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
obwieścić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
obwieścić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
obwiniać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
obwiniać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
obwiniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(o,acc); prepncp(o,acc,że)}
obwiniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(za,acc); prepncp(za,acc,że)}
obwiniać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {refl}
obwiniać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {refl}
obwinić: _: : perf: subj{np(str)} + {cp(że)} + {refl}
obwinić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
obwinić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(o,acc); prepncp(o,acc,że)}
obwinić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(za,acc); prepncp(za,acc,że)}
obwinić: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {refl}
obwinić: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {refl}
obyczaj: : : : {fixed('lekkie')}
obyczaj: : : : {np(gen)} + {possp}
obyczaj: : : : {possp} + {comprepnp(w kwestii)}
obyczaj: : : : {possp} + {comprepnp(w sprawie)}
obyczaj: : : : {possp} + {cp(że)}
obyczaj: : : : {possp} + {cp(żeby)}
obyczaj: : : : {possp} + {prepnp(co do,gen)}
obyczaj: : : : {possp} + {prepnp(o,loc)}
obyczaj: : : : {possp} + {xp(locat)}
obyć się: _: : perf: subj{np(str)} + {np(inst)}
obyć się: _: : perf: subj{np(str)} + {prepnp(bez,gen); prepncp(bez,gen,że); prepncp(bez,gen,żeby)}
obyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
obywać się: _: : imperf: subj{np(str)} + {np(inst)}
obywać się: _: : imperf: subj{np(str)} + {prepnp(bez,gen); prepncp(bez,gen,że); prepncp(bez,gen,żeby)}
obywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
obżynać się: _: : imperf: subj{np(str)}
obżynać: _: : imperf: subj{np(str)} + obj{np(str)}
ocalać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
ocalać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
ocalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ocalać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
ocalać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
ocalać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
ocaleć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
ocaleć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ocalić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
ocalić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
ocalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ocalić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
ocalić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
ocalić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
ocechować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oceniać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
oceniać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
oceniać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
oceniać: _: : imperf: subj{np(str)} + {cp(int)}
oceniać: _: : imperf: subj{np(str)} + {cp(że)}
oceniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
oceniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oceniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
oceniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oceniać: _: : imperf: subj{np(str)} + {or} + {refl}
oceniać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
ocenić: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
ocenić: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
ocenić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
ocenić: _: : perf: subj{np(str)} + {cp(int)}
ocenić: _: : perf: subj{np(str)} + {cp(że)}
ocenić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
ocenić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
ocenić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ocenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ocenić: _: : perf: subj{np(str)} + {or} + {refl}
ocenić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
ocenzurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocenzurować: _: : perf: subj{np(str)} + {refl}
ochlapać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ochlapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ochlapywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ochlapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ochładzać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
ochładzać się: _: : imperf: {xp(locat)}
ochładzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ochładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ochłodzić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
ochłodzić się: _: : perf: {xp(locat)}
ochłodzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ochłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ochłonąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ochraniać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochraniać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
ochraniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {refl}
ochraniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {refl}
ochraniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochraniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
ochrona: : : : {np(gen)} + {adjp(agr); prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {possp}
ochrona: : : : {np(gen)} + {preplexnp(w,loc,pl,'rama',atr)}
ochrona: : : : {np(gen)} + {prepnp(od,gen)}
ochrona: : : : {np(gen)} + {prepnp(przeciw,dat)}
ochrona: : : : {np(gen)} + {prepnp(wobec,gen)}
ochrona: : : : {np(gen)} + {prepnp(względem,gen)}
ochrona: : : : {possp} + {prepnp(dla,gen)}
ochronić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochronić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
ochronić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {refl}
ochronić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {refl}
ochronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
ochrzcić się: _: : perf: subj{np(str)}
ochrzcić: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
ochrzcić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
ochrzcić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
ochrzcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ociągać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ociec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ociec: _: : perf: subj{np(str)} + {np(inst)}
ociekać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
ocieniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
ocieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
ocienić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
ocienić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
ocierać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
ocierać się: _: : imperf: subj{np(str)} + {xp(locat)}
ocierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
ocierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
ocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
ocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
ocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
ociosać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
ociosać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
ociosać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
ociosywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
ociosywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
ociosywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
ocknąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ocknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ocucić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ocucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
oczarować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
oczarować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
oczarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
oczekiwać: _: : imperf: subj{np(str)} + {cp(aż)}
oczekiwać: _: : imperf: subj{np(str)} + obj{np(gen); cp(że); cp(żeby); ncp(gen,że); ncp(gen,żeby)} + {prepnp(od,gen)}
oczekiwać: _: : imperf: subj{np(str)} + obj{np(gen); cp(że); cp(żeby); ncp(gen,że); ncp(gen,żeby)} + {prepnp(po,loc)}
oczekiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
oczerniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
oczerniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)} + {refl}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(wobec,gen)}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
oczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oczerniać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {refl}
oczerniać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(wobec,gen)} + {refl}
oczerniać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {refl}
oczerniać: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)} + {refl}
oczernić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
oczernić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)} + {refl}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(wobec,gen)}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
oczernić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oczernić: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {refl}
oczernić: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(wobec,gen)} + {refl}
oczernić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {refl}
oczernić: _: : perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)} + {refl}
oczyszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
oczyszczać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
oczyszczać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oczyszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oczyszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oczyścić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
oczyścić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
oczyścić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oczytać się: _: : perf: subj{np(str)} + {np(dat)}
oczytać się: _: : perf: subj{np(str)} + {np(gen)}
oczytać się: _: : perf: subj{np(str)} + {np(inst)}
oczytać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
odąć się: _: : perf: subj{np(str)} + {cp(że)}
odąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
odąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
odąć się: _: : perf: subj{np(str)} + {or}
odąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odąć: _: : perf: subj{np(str)} + obj{np(str)}
odbąknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odbąknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odbąknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odbąknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odbezpieczać się: _: : imperf: subj{np(str)} + {np(dat)}
odbezpieczać: _: : imperf: subj{np(str)} + obj{np(str)}
odbezpieczyć się: _: : perf: subj{np(str)} + {np(dat)}
odbezpieczyć: _: : perf: subj{np(str)} + obj{np(str)}
odbić się: _: : perf: {np(dat)} + {np(inst)}
odbić się: _: : perf: subj{np(str); ncp(str,że)} + controller{prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)} + controllee{xp(mod)}
odbić się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'czkawka',atr)}
odbić się: _: : perf: subj{np(str); ncp(str,że)} + {xp(locat)} + {lexnp(inst,sg,'echo',atr)}
odbić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odbić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
odbić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
odbić: _: : perf: {np(dat)}
odbić: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odbić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'ręka',ratr)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odbić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odbiec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odbiec: _: : perf: subj{np(str)} + {np(str)}
odbiec: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
odbiegać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odbiegać: _: : imperf: subj{np(str)} + {np(str)}
odbiegać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
odbierać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odbijać się: _: : imperf: {np(dat)} + {np(inst)}
odbijać się: _: : imperf: subj{np(str); ncp(str,że)} + controller{prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)} + controllee{xp(mod)}
odbijać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'czkawka',atr)}
odbijać się: _: : imperf: subj{np(str); ncp(str,że)} + {xp(locat)} + {lexnp(inst,sg,'echo',atr)}
odbijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odbijać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
odbijać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbijać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
odbijać: _: : imperf: {np(dat)}
odbijać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbijać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'ręka',ratr)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odbudować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odbudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odbudowywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
odbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odbyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
odbyć się: _: : perf: subj{np(str)} + {xp(locat)}
odbyć się: _: : perf: subj{np(str)} + {xp(temp)}
odbyć: _: : perf: subj{np(str)} + obj{np(str)}
odbywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
odbywać się: _: : imperf: subj{np(str)} + {xp(locat)}
odbywać się: _: : imperf: subj{np(str)} + {xp(temp)}
odbywać: _: : imperf: subj{np(str)} + obj{np(str)}
odchodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odchodzić: _: : imperf: subj{np(str)} + {np(str)}
odchodzić: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {comprepnp(na rzecz)}
odchodzić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(od,gen,pl,'zmysł',natr)}
odchodzić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(od,gen,sg,'rozum',natr)}
odchodzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odchodzić: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
odchować się: _: : perf: subj{np(str)}
odchować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odchować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odchowywać się: _: : imperf: subj{np(str)}
odchowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odchowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odchylać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
odchylać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(od,gen)}
odchylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
odchylić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
odchylić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(od,gen)}
odchylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
odciąć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
odciąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
odciąć się: _: : perf: subj{np(str)} + {np(dat)} + {or}
odciąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odciągać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
odciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odciągnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
odciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odcierpieć: _: : perf: subj{np(str)} + obj{np(str)}
odcierpieć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
odcinać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odciskać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
odciskać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(inst,sg,'piętno',atr)}
odciskać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'piętno',atr)} + {np(inst)} + {prepnp(na,loc)}
odciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
odciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odcisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
odcisnąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(inst,sg,'piętno',atr)}
odcisnąć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'piętno',atr)} + {np(inst)} + {prepnp(na,loc)}
odcisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
odcisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odczarować się: _: : perf: subj{np(str)}
odczarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odczekać: _: : perf: subj{np(str)} + {np(str)} + {cp(aż)}
odczepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odczepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odczepić się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odczuć: _: : perf: subj{np(str)} + {cp(żeby2)}
odczuć: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
odczuć: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
odczuć: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
odczuć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
odczuwać: _: : imperf: subj{np(str)} + {cp(int)}
odczuwać: _: : imperf: subj{np(str)} + {cp(jak)}
odczuwać: _: : imperf: subj{np(str)} + {cp(jakoby)}
odczuwać: _: : imperf: subj{np(str)} + {cp(że)}
odczuwać: _: : imperf: subj{np(str)} + {cp(żeby2)}
odczuwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczuwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2)}
odczytać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczytać: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odczytać: _: : perf: subj{np(str)} + {or}
odczytywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczytywać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odczytywać: _: : imperf: subj{np(str)} + {or}
oddać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'dyspozycja',atr)}
oddać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'niewola',atr)}
oddać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
oddać: _: : perf: subj{np(str)} + {np(dat)} + {adjp(inst)} + {prepadjp(za,acc)}
oddać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
oddać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
oddać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
oddać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oddać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oddać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
oddać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
oddalać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
oddalać się: _: : imperf: subj{np(str)} + {xp(abl)}
oddalać się: _: : imperf: subj{np(str)} + {xp(adl)}
oddalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oddalić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
oddalić się: _: : perf: subj{np(str)} + {xp(abl)}
oddalić się: _: : perf: subj{np(str)} + {xp(adl)}
oddalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oddawać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'dyspozycja',atr)}
oddawać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'niewola',atr)}
oddawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddawać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
oddawać: _: : imperf: subj{np(str)} + {np(dat)} + {adjp(inst)} + {prepadjp(za,acc)}
oddawać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
oddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
oddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
oddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
oddłużać się: _: : imperf: subj{np(str)}
oddłużać: _: : imperf: subj{np(str)} + obj{np(str)}
oddłużyć się: _: : perf: subj{np(str)}
oddłużyć: _: : perf: subj{np(str)} + obj{np(str)}
oddychać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst); prepnp(przez,acc)}
oddychać: _: : imperf: subj{np(str)} + {np(inst); prepnp(przez,acc)}
oddziałać: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
oddziaływać: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
oddzielać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
oddzielać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
oddzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oddzielić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
oddzielić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
oddzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oddzwaniać: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
oddzwaniać: _: : imperf: subj{np(str)} + {cp(int)} + {xp(abl)} + {xp(adl)}
oddzwaniać: _: : imperf: subj{np(str)} + {cp(że)} + {xp(abl)} + {xp(adl)}
oddzwaniać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {xp(abl)} + {xp(adl)}
oddzwonić: _: : perf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
oddzwonić: _: : perf: subj{np(str)} + {cp(int)} + {xp(abl)} + {xp(adl)}
oddzwonić: _: : perf: subj{np(str)} + {cp(że)} + {xp(abl)} + {xp(adl)}
oddzwonić: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {xp(abl)} + {xp(adl)}
odebrać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odebrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odebrać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odechcieć się: _: : perf: controller{np(dat)} + controllee{infp(_)}
odechcieć się: _: : perf: {np(dat)} + {np(gen)}
odechciewać się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
odechciewać się: _: : imperf: {np(dat)} + {np(gen)}
odegnać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odegnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odegnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odegrać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odegrać się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odegrać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
odegrać się: _: : perf: subj{np(str)} + {xp(locat)}
odegrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odegrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
odegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odegrać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(str,sg,'rola',atr)}
odejmować: _: : imperf: {np(dat)} + {np(str)}
odejmować: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'rok',natr)}
odejmować: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
odejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odejść: _: : perf: subj{np(str)} + {np(str)}
odejść: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {comprepnp(na rzecz)}
odejść: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odepchnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odeprzeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
odeprzeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odeprzeć: _: : perf: subj{np(str)} + {np(dat)} + {or}
odeprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
oderwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
oderwać się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {lexnp(inst,_,'myśl',natr)}
oderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oderwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odesłać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,inst,sg,'kwitek',natr)}
odesłać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
odessać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odessać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(perl)}
odetchnąć: _: : perf: subj{np(str)} + {np(inst)}
odetchnąć: _: : perf: subj{np(str)} + {prepnp(po,loc)}
odetchnąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
odezwać się: _: : perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)} + {or}
odezwać się: _: : perf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
odezwać się: _: : perf: subj{np(str)} + {cp(że)}
odezwać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odezwać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
odezwać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
odezwać się: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {or}
odezwać się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
odezwać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
odformalizować: _: : perf: subj{np(str)} + obj{np(str)}
odgadnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odgadnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odgadnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
odgadywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odgadywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odgadywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
odgałęziać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
odganiać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odgarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odgarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odgiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odgiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
odgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
odginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
odginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
odgonić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odgonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odgonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odgrażać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odgrażać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odgrażać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
odgrywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odgrywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odgrywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
odgrywać się: _: : imperf: subj{np(str)} + {xp(locat)}
odgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
odgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odgrywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(str,sg,'rola',atr)}
odgryzać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odgryzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odgryźć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odgryźć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odgrzać się: _: : perf: subj{np(str)} + {xp(locat)}
odgrzać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
odgrzewać się: _: : imperf: subj{np(str)} + {xp(locat)}
odgrzewać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
odgwizdać: _: : perf: subj{np(str)} + {cp(że)}
odgwizdać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
odgwizdywać: _: : imperf: subj{np(str)} + {cp(że)}
odgwizdywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
odjąć: _: : perf: {np(dat)} + {np(str)}
odjąć: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'rok',natr)}
odjąć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
odjąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odjąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odkazić się: _: : perf: subj{np(str)} + {xp(locat)}
odkazić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
odkazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkazić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odkażać się: _: : imperf: subj{np(str)} + {xp(locat)}
odkażać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
odkażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkażać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odkładać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
odkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
odkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
odkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odkopać: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {refl}
odkopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odkopać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odkopywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {refl}
odkopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odkopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odkorkować się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
odkorkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkrajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odkrajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odkrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odkrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odkręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odkręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odkręcać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
odkręcać się: _: : imperf: subj{np(str)} + {xp(adl)}
odkręcać: _: : imperf: subj{np(str)} + {cp(że)}
odkręcać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
odkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odkręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odkręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odkręcić się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
odkręcić się: _: : perf: subj{np(str)} + {xp(adl)}
odkręcić: _: : perf: subj{np(str)} + {cp(że)}
odkręcić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
odkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odkroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odkroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odkryć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
odkryć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
odkryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odkryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
odkryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odkryć: _: : perf: subj{np(str)} + {or}
odkryć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
odkryć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
odkrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
odkrywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
odkrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odkrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
odkrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odkrywać: _: : imperf: subj{np(str)} + {or}
odkrywać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
odkrywać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
odkrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odkrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odkrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odkrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odkrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odkrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
odkrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int)}
odkrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
odkrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(żeby)}
odkrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {or}
odkrzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odkrzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odkrzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odkrzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odkrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odkrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
odkrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int)}
odkrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
odkrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(żeby)}
odkrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {or}
odkształcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odkształcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odkształcać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
odkształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odkształcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odkształcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odkształcić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
odkształcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkształcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odkuć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
odkuć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odkuć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {refl}
odkuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odkuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odkupić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odkupić: _: : perf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
odkupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odkupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odkupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odkupić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); xp(abl)} + {prepnp(za,acc)}
odkurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odkurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odkuwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
odkuwać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odkuwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {refl}
odkuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odkuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odlatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odlatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
odlatywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odlatywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
odlecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odlecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
odlecieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odlecieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odleźć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odliczać się: _: : imperf: subj{np(str)} + {xp(locat)}
odliczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(od,gen)}
odliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odliczać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
odliczyć się: _: : perf: subj{np(str)} + {xp(locat)}
odliczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(od,gen)}
odliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odliczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
odłamać się: _: : perf: subj{np(str)} + {np(dat)}
odłamać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odłamać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odłamywać się: _: : imperf: subj{np(str)} + {np(dat)}
odłamywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odłamywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
odłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odłazić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odłączać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odłączyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odłowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odłożyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
odłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
odłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
odłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odmaterializować: _: : perf: subj{np(str)} + obj{np(str)}
odmawiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że)}
odmawiać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
odmawiać: _: : imperf: subj{np(str)} + obj{np(str)}
odmiana: : : : {comprepnp(w sprawie)}
odmiana: : : : {np(gen)} + {prepadjp(na,acc)}
odmiana: : : : {np(gen)} + {prepnp(dla,gen)}
odmiana: : : : {np(gen)} + {prepnp(przez,acc)}
odmiana: : : : {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odmieniać się: _: : imperf: {np(dat)}
odmieniać się: _: : imperf: subj{np(str)} + {np(dat)}
odmieniać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
odmieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
odmienić się: _: : perf: {np(dat)}
odmienić się: _: : perf: subj{np(str)} + {np(dat)}
odmienić się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
odmienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
odmienny: : : : {comp(jak)}
odmienny: : : : {prepnp(co do,gen)}
odmienny: : : : {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(w,loc)}
odmienny: : : : {prepnp(przez,acc)}
odmienny: : : : {prepnp(w,loc)} + {comp(niż)}
odmierzać: _: : imperf: subj{np(str)} + {cp(int)}
odmierzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odmierzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(na,loc)}
odmierzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
odmierzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {xp(adl)}
odmierzyć: _: : perf: subj{np(str)} + {cp(int)}
odmierzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odmierzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(na,loc)}
odmierzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
odmierzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {xp(adl)}
odmładzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
odmładzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
odmładzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {refl}
odmładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
odmłodzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
odmłodzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
odmłodzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {refl}
odmłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
odmówić: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,że)} + {np(dat)}
odmówić: _: : perf: subj{np(str)} + obj{np(str)}
odmrażać się: _: : imperf: subj{np(str)} + {np(dat)}
odmrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odmrozić się: _: : perf: subj{np(str)} + {np(dat)}
odmrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odnajdywać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
odnajdywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
odnajdywać się: _: : imperf: subj{np(str)} + {xp(locat)}
odnajdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
odnajdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
odnaleźć się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
odnaleźć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
odnaleźć się: _: : perf: subj{np(str)} + {xp(locat)}
odnaleźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
odnaleźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); prepnp(w,loc); prepncp(w,loc,że)}
odnawiać się: _: : imperf: subj{np(str)} + {np(dat)}
odnawiać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
odnawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odnieść się: _: : perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
odnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odnieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odnosić się: _: : imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
odnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odnotować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
odnotować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
odnotować: _: : perf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
odnotować: _: : perf: subj{np(str)} + obj{cp(żeby2)} + {xp(locat)}
odnotować: _: : perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
odnotować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {xp(locat)}
odnotować: _: : perf: subj{np(str)} + {or}
odnotowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
odnotowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
odnotowywać: _: : imperf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
odnotowywać: _: : imperf: subj{np(str)} + obj{cp(żeby2)} + {xp(locat)}
odnotowywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
odnotowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {xp(locat)}
odnotowywać: _: : imperf: subj{np(str)} + {or}
odnowić się: _: : perf: subj{np(str)} + {np(dat)}
odnowić się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
odnowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odosobniać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
odosobniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odosobniać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odosobniać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
odosobnić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
odosobnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odosobnić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odosobnić: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
odpadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odpadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpalać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpalać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpalać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odpalić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpalić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpalić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odpalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odpalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odpalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odpalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odpalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odparować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
odparować: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odparować: _: : perf: subj{np(str)} + {np(dat)} + {or}
odparować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odparować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odparować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odparować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odparować: _: : perf: subj{np(str)} + {xp(abl)}
odparować: _: : perf: subj{np(str)} + {xp(adl)}
odparowywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odparowywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odparowywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
odparowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odparowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odparowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odparowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odparowywać: _: : imperf: subj{np(str)} + {xp(abl)}
odparowywać: _: : imperf: subj{np(str)} + {xp(adl)}
odpasać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
odpasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odpasać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odpasywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odpaść się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
odpaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odpaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpaść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odpędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odpędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odpędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odpiąć się: _: : perf: subj{np(str)} + {np(dat)}
odpiąć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odpiąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
odpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpiąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odpiąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
odpierać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odpierać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odpierać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
odpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
odpierdolić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odpierdolić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
odpierdolić: _: : perf: {np(dat)}
odpierdolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odpisać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpisać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpisać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpisać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpisać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
odpisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odpisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
odpisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
odpisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
odpisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odpisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
odpisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
odpisywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpisywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpisywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpisywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpisywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
odpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
odpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
odpisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
odpisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odpisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
odpisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
odplątać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
odplątać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
odplątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odplątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odplątywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
odplątywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
odplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odpłacać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłacać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłacać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłacać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłacić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłacić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłacić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłacić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpłynąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odpłynąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpłynąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odpływać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odpływać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpływać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odpocząć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odpocząć: _: : perf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
odpoczywać: _: : imperf: subj{np(str)} + {preplexnp(w,loc,sg,'pokój',atr)}
odpoczywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odpoczywać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
odpowiadać: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
odpowiadać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(na,acc)}
odpowiadać: _: : imperf: subj{cp(że)} + {np(dat)}
odpowiadać: _: : imperf: subj{np(str)} + {ncp(dat,żeby)}
odpowiadać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
odpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpowiadać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odpowiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odpowiadać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
odpowiadać: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
odpowiadać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
odpowiedzieć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(na,acc)}
odpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpowiedzieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odpowiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odpowiedzieć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpowiedzieć: _: : perf: subj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
odpowiedzieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odprasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odprasowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odprawiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
odprawiać się: _: : imperf: subj{np(str)} + {xp(locat)}
odprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odprawić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
odprawić się: _: : perf: subj{np(str)} + {xp(locat)}
odprawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odprężać się: _: : imperf: subj{np(str)} + {advp(misc)}
odprężać się: _: : imperf: subj{np(str)} + {np(inst)}
odprężać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
odprężać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
odprężać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
odprężać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odprężyć się: _: : perf: subj{np(str)} + {advp(misc)}
odprężyć się: _: : perf: subj{np(str)} + {np(inst)}
odprężyć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
odprężyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
odprężyć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
odprężyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odpukać: _: : perf: subj{np(str)} + {np(dat)}
odpukać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
odpuszczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odpuszczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odpuszczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
odpuścić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
odpuścić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odpuścić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
odpychać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odpychać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
odpychać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
odpychać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {preplexnp(od,gen,_,'siebie',natr)}
odpychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odpytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
odpytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
odpytać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
odpytać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
odpytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
odpytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int)}
odpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
odpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
odpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
odpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
odpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
odpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int)}
odrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odradzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
odradzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odradzać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
odradzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
odradzić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odradzić: _: : perf: subj{np(str)} + {np(dat)} + {or}
odradzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
odrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odreagować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odreagować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odreagować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odreagować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odreagować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
odreagowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odreagowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odreagowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odreagowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odreagowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
odrestaurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odrodzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odrodzić: _: : perf: subj{np(str)} + obj{np(str)}
odróżniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(od,gen)}
odróżniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen)}
odróżniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
odróżniać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
odróżniać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
odróżnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(od,gen)}
odróżnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen)}
odróżnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
odróżnić: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
odróżnić: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
odrywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odrywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {lexnp(inst,_,'myśl',natr)}
odrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odrzec się: _: : perf: subj{np(str)} + {np(gen)}
odrzec się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odrzec: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
odrzec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odrzec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odrzec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
odrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odrzucać: _: : imperf: {np(str)} + {prepnp(od,gen)}
odrzucać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(od,gen)}
odrzucać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(od,gen)}
odrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odrzucić: _: : perf: {np(str)} + {prepnp(od,gen)}
odrzucić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(od,gen)}
odrzucić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(od,gen)}
odrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odsapnąć: _: : perf: subj{np(str)} + {or}
odsapnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odsapnąć: _: : perf: subj{np(str)} + {prepnp(po,loc)}
odsapnąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
odsączać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
odsączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
odsączyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odsączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
odsądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsądzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsiadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odsiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odsłaniać się: _: : imperf: subj{np(str)} + {np(dat)}
odsłaniać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
odsłaniać się: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
odsłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odsłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odsłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
odsłonić się: _: : perf: subj{np(str)} + {np(dat)}
odsłonić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
odsłonić się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
odsłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odsłonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odsłonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
odsłuchać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odsłuchać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odsłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odsłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odsługiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odsługiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odsługiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odsłużyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
odsłużyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odsłużyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odstawać się: _: : imperf: subj{np(str)}
odstawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odstawać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
odstawać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odstawać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
odstawać: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(od,gen)}
odstawać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,loc)}
odstawać: _: : imperf: subj{np(str)} + {xp(adl)}
odstawiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
odstawiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
odstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odstawić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
odstawić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
odstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odstawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odstąpić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odstąpić: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
odstępować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odstępować: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
odstraszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
odstraszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
odstraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
odstraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
odstraszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
odstraszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
odstraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
odstraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
odstrzelić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
odstrzelić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odstrzeliwać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odstrzeliwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odstrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odstrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odsunąć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odsunąć się: _: : perf: subj{np(str)} + {xp(adl)}
odsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odsuwać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odsuwać się: _: : imperf: subj{np(str)} + {xp(adl)}
odsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,inst,sg,'kwitek',natr)}
odsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
odsypać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
odsypać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odsypywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
odsypywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odsysać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odsysać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(perl)}
odszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
odszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odszeptać: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
odszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
odszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odszukać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)} + {xp(locat)}
odszukać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
odszukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
odszukiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)} + {xp(locat)}
odszukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
odszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
odszyfrować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odszyfrować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odszyfrować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
odszyfrowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odszyfrowywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odszyfrowywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
odśpiewać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
odśpiewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odśpiewywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
odśpiewywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odśrubować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odświeżać się: _: : imperf: subj{np(str)} + {np(dat)}
odświeżać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
odświeżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odświeżyć się: _: : perf: subj{E}
odświeżyć się: _: : perf: subj{np(str)} + {np(dat)}
odświeżyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
odświeżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odtaczać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odtaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odtańczyć: _: : perf: subj{np(str)} + obj{np(str)}
odtoczyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odtoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odtrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odtrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odtrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odtrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odtwarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odtwarzać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
odtwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odtwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
odtwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odtworzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odtworzyć: _: : perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
odtworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odtworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
odtworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odtykać się: _: : imperf: subj{np(str)} + {np(dat)}
odtykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oduczyć się: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)}
oduczyć się: _: : perf: subj{np(str)} + {cp(że)}
oduczyć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)} + {np(inst)}
oduczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
oduczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)}
oduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
oduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)} + {np(inst)}
oduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
odumierać: _: : imperf: subj{np(str)} + {np(str)}
odumrzeć: _: : perf: subj{np(str)} + {np(str)}
odurzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
odurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odurzyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
odurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odwadniać się: _: : imperf: subj{np(str)}
odwadniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odwaga: : : : {np(gen)} + {possp}
odwaga: : : : {possp} + {comprepnp(co do)}
odwaga: : : : {possp} + {comprepnp(w kwestii)}
odwaga: : : : {possp} + {comprepnp(w sprawie)}
odwaga: : : : {possp} + {comprepnp(w stosunku do)}
odwaga: : : : {possp} + {cp(żeby)}
odwaga: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
odwaga: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
odwaga: : : : {possp} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
odwaga: : : : {possp} + {prepnp(wobec,gen)}
odwaga: : : : {possp} + {prepnp(względem,gen)}
odważać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
odważać się: _: : imperf: subj{np(str)} + {cp(żeby)}
odważać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
odważać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odważać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
odważyć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
odważyć się: _: : perf: subj{np(str)} + {cp(żeby)}
odważyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
odważyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odważyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
odwdzięczać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwdzięczać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwdzięczyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwdzięczyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwiać: _: : perf: {np(dat)} + {np(str)} + {xp(abl)}
odwiać: _: : perf: {np(dat)} + {np(str)} + {xp(adl)}
odwiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
odwiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odwiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odwiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odwiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odwiedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odwiedzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odwieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
odwieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odwiewać: _: : imperf: {np(dat)} + {np(str)} + {xp(abl)}
odwiewać: _: : imperf: {np(dat)} + {np(str)} + {xp(adl)}
odwiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
odwiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odwiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odwiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odwiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odwijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odwijać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odwijać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
odwikłać: _: : perf: subj{np(str)} + obj{np(str)}
odwinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
odwinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odwinąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
odwinąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
odwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odwinąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
odwlec się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
odwlec się: _: : perf: subj{np(str)} + {xp(dur)}
odwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odwlec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odwlec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
odwlekać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
odwlekać się: _: : imperf: subj{np(str)} + {xp(dur)}
odwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
odwodnić się: _: : perf: subj{np(str)}
odwodnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
odwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odwołać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
odwołać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odwołać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
odwołać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
odwołać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen); prepncp(od,gen,że)}
odwołać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
odwołać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwołać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
odwoływać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
odwoływać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odwoływać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
odwoływać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
odwoływać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen); prepncp(od,gen,że)}
odwoływać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
odwoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
odwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
odwracać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwracać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odwracać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
odwracać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
odwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
odwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odwrócić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwrócić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odwrócić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
odwrócić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
odwrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odwrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odwykać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
odwykać: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
odwyknąć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
odwyknąć: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
odwzajemniać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwzajemniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odwzajemnić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwzajemnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odymać się: _: : imperf: subj{np(str)} + {cp(że)}
odymać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odymać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
odymać się: _: : imperf: subj{np(str)} + {or}
odymać: _: : imperf: subj{np(str)} + obj{np(str)}
odziać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {refl}
odziać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)} + {refl}
odziać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
odziać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)}
odziedziczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
odzierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
odzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odziewać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {refl}
odziewać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)} + {refl}
odziewać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
odziewać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)}
odznaczać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
odznaczać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
odznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odznaczyć się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
odznaczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
odznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odzwierciedlać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
odzwierciedlać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
odzwierciedlić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
odzwierciedlić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
odzwyczajać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {np(inst)} + {refl}
odzwyczajać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)} + {refl}
odzwyczajać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)} + {np(inst)}
odzwyczajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odzyskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odzyskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odzyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odzyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odzywać się: _: : imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)} + {or}
odzywać się: _: : imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
odzywać się: _: : imperf: subj{np(str)} + {cp(że)}
odzywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odzywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
odzywać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
odzywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
odzywać się: _: : imperf: subj{np(str)} + {xp(locat)} + {or}
odżyć: _: : perf: subj{np(str)} + {np(inst)}
odżywać: _: : imperf: subj{np(str)} + {np(inst)}
odżywiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
odżywiać się: _: : imperf: subj{np(str)} + {np(inst)}
odżywiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odżywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oferować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
oferować się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oferować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
oferować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oferować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
oferta: : : : {np(gen)} + {possp}
oferta: : : : {possp} + {comprepnp(na temat)}
oferta: : : : {possp} + {comprepnp(w kwestii)}
oferta: : : : {possp} + {comprepnp(w sprawie)}
oferta: : : : {possp} + {cp(że)}
oferta: : : : {possp} + {cp(żeby)}
oferta: : : : {possp} + {or}
oferta: : : : {possp} + {prepnp(co do,gen)}
oferta: : : : {possp} + {prepnp(dla,gen)}
oferta: : : : {possp} + {prepnp(na,acc)}
ofiara: : : : {possp} + {comprepnp(na rzecz)}
ofiara: : : : {possp} + {prepnp(dla,gen)} + {prepnp(na,acc)}
ofiara: : : : {possp} + {prepnp(dla,gen)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
ofiara: : : : {possp} + {prepnp(dla,gen)} + {prepnp(z,gen)}
ofiara: : : : {possp} + {prepnp(wobec,gen)}
ofiarować się: _: : _: subj,controller{np(str)} + controllee{infp(_)}
ofiarować się: _: : _: subj{np(str)} + {cp(że)}
ofiarować się: _: : _: subj{np(str)} + {or}
ofiarować się: _: : _: subj{np(str)} + {prepnp(z,inst)}
ofiarować: _: : _: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
ofiarować: _: : _: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {refl}
ofiarować: _: : _: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
ofiarować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ofiarować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
ofiarować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
ofiarować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
ofiarowywać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
ofiarowywać się: _: : imperf: subj{np(str)} + {cp(że)}
ofiarowywać się: _: : imperf: subj{np(str)} + {or}
ofiarowywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ofiarowywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
ofiarowywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {refl}
ofiarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ofiarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
ofiarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
oflagować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oflagować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ofukać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
ofukać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
ofukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ofuknąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
ofuknąć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
ofuknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ogarnąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ogarnąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
ogarnąć: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
ogarnąć: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
ogarnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ogarnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
ogarniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
ogarniać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ogarniać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
ogarniać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
ogarniać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ogarniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
oglądać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
oglądać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
oglądać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
oglądać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oglądać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w roli)}
oglądać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
oglądać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
oglądać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
oglądać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
oglądać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
ogłaszać się: _: : imperf: subj{np(str)} + {or}
ogłaszać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
ogłaszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
ogłaszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
ogłaszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
ogłaszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
ogłaszać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
ogłaszać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
ogłaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ogłaszać: _: : imperf: subj{np(str)} + {or}
ogłaszać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
ogłosić: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
ogłosić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
ogłosić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
ogłosić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
ogłosić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
ogłosić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
ogłosić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
ogłosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ogłosić: _: : perf: subj{np(str)} + {or}
ogłosić: _: : perf: subj{np(str)} + {prepnp(o,loc)}
ogłoszenie: : : : {possp} + {comprepnp(na temat)}
ogłoszenie: : : : {possp} + {comprepnp(w kwestii)}
ogłoszenie: : : : {possp} + {comprepnp(w sprawie)}
ogłoszenie: : : : {possp} + {cp(int)}
ogłoszenie: : : : {possp} + {cp(jakoby)}
ogłoszenie: : : : {possp} + {cp(że); cp(żeby)}
ogłoszenie: : : : {possp} + {or}
ogłoszenie: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
ogłuchnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
ogłupiać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
ogłupiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
ogłupiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
ogłupiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ogłupić: _: : perf: subj{np(str)} + {cp(że)} + {refl}
ogłupić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
ogłupić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
ogłupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ogłuszać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ogłuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ogłuszyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ogłuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ogolić: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
ogolić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
ogolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
ogolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ogolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
ogolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ograniczać się: _: : imperf: subj{np(str)} + {np(inst)}
ograniczać się: _: : imperf: subj{np(str)} + {prepncp(do,gen,że)}
ograniczać się: _: : imperf: subj{np(str)} + {prepncp(do,gen,żeby)}
ograniczać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
ograniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ograniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ograniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
ograniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ograniczyć się: _: : perf: subj{np(str)} + {np(inst)}
ograniczyć się: _: : perf: subj{np(str)} + {prepncp(do,gen,że)}
ograniczyć się: _: : perf: subj{np(str)} + {prepncp(do,gen,żeby)}
ograniczyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
ograniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ograniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ograniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
ograniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ogryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ogryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ogryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ogryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ogrzać się: _: : perf: subj{np(str)} + {np(inst)}
ogrzać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
ogrzać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
ogrzać się: _: : perf: subj{np(str)} + {xp(locat)}
ogrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
ogrzewać się: _: : imperf: subj{np(str)} + {np(inst)}
ogrzewać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
ogrzewać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
ogrzewać się: _: : imperf: subj{np(str)} + {xp(locat)}
ogrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
okalać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
okalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
okalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
okazać się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
okazać się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
okazać się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
okazać się: _: : perf: subj{cp(int)}
okazać się: _: : perf: subj{cp(że)}
okazać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
okazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
okazywać się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
okazywać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
okazywać się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
okazywać się: _: : imperf: subj{cp(int)}
okazywać się: _: : imperf: subj{cp(że)}
okazywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
okazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
okiełznać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okiełznywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oklaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
okleić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
okleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
okleić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
oklejać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
oklejać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
okładać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
okładać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
okładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
okładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
okłamać: _: : perf: subj{np(str)} + {cp(że)} + {refl}
okłamać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
okłamać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
okłamać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
okłamać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
okłamać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
okłamać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
okłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okłamywać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
okłamywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
okłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
okłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
okłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
okłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
okłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
okłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
okno: : : : {np(gen)} + {possp}
okno: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,żeby)}
okno: : : : {possp} + {prepnp(na,acc)}
okno: : : : {possp} + {prepnp(od,gen)}
okocić się: _: : perf: subj{np(str)}
okoliczność: : : : {comprepnp(w kwestii)}
okoliczność: : : : {comprepnp(w sprawie)}
okoliczność: : : : {cp(gdy)}
okoliczność: : : : {cp(int)}
okoliczność: : : : {cp(kiedy)}
okoliczność: : : : {cp(że)}
okoliczność: : : : {np(gen)}
okoliczność: : : : {prepnp(co do,gen)}
okolić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
okolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
okolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okpić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okpić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
okpiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okpiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
okraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
okradać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okradać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
okraść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okraść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
okrążać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
okrążać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
okrążać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
okrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
okrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
określać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
określać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
określać: _: : imperf: subj{np(str)} + {cp(int)}
określać: _: : imperf: subj{np(str)} + {cp(że)}
określać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
określać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
określać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
określać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
określać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
określić się: _: : perf: subj{np(str)} + {cp(int)}
określić się: _: : perf: subj{np(str)} + {cp(że)}
określić: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
określić: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
określić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
określić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
określić: _: : perf: subj{np(str)} + obj{cp(int)}
określić: _: : perf: subj{np(str)} + obj{cp(że)}
okroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okrwawić się: _: : perf: subj{np(str)}
okrwawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
okrzepnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
okuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
okuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
okupić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
okupić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
okupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
okupować: _: : imperf: subj{np(str)} + obj{np(str)}
okupywać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
okupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
okupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
okuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
okuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
okwitać: _: : imperf: subj{np(str)}
okwitnąć: _: : perf: subj{np(str)}
olać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
olewać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
omamić: _: : perf: subj{np(str)} + {cp(że)} + {refl}
omamić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
omamić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
omamić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
omamić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
omarznąć: _: : perf: subj{np(str)}
omaszczać się: _: : imperf: subj{np(str)} + {np(inst)}
omaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
omaścić się: _: : perf: subj{np(str)} + {np(inst)}
omaścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
omawiać: _: : imperf: subj{np(str)} + {cp(int)}
omawiać: _: : imperf: subj{np(str)} + {cp(że)}
omawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
omdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
omdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
omdlewać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
omdlewać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
omiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
omiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
omieszkać: neg: : perf: subj,controller{np(str)} + controllee{infp(_)}
omieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
omieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
omijać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
omijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
omijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
omijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
omijać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
ominąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
ominąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ominąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
ominąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ominąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
omłócić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
omówić: _: : perf: subj{np(str)} + {cp(int)}
omówić: _: : perf: subj{np(str)} + {cp(że)}
omówić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
omylić się: _: : perf: subj{np(str)} + {prepnp(co do,gen)}
omylić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
omylić: _: : perf: subj{np(str)} + obj{np(str)}
oniemieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
onieśmielać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
onieśmielać: _: : imperf: subj{cp(że)} + {np(str)}
onieśmielać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen)}
onieśmielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
onieśmielić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
onieśmielić: _: : perf: subj{cp(że)} + {np(str)}
onieśmielić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen)}
onieśmielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
opadać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
opadać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
opadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
opadać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
opakować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
opakować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
opakowywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
opakowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opakowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
opakowywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
opalać się: _: : imperf: subj{np(str)} + {np(dat)}
opalać: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
opalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)} + {prepnp(z,gen)}
opalić się: _: : perf: subj{np(str)} + {np(dat)}
opalić: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
opalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)} + {prepnp(z,gen)}
opancerzyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opancerzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opanować się: _: : perf: subj{np(str)}
opanować: _: : perf: subj{np(str)} + obj{np(str)}
opanowywać się: _: : imperf: subj{np(str)}
opanowywać: _: : imperf: subj{np(str)} + obj{np(str)}
oparzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
oparzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
oparzyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
oparzyć: _: : perf: subj{E} + {np(str)}
oparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
oparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
opasać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
opasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
opasywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
opasywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
opaść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
opaść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
opaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
opaść: _: : perf: subj{np(str)} + {prepnp(o,acc)}
opatentować: _: : perf: subj{np(str)} + obj{cp(int)}
opatentować: _: : perf: subj{np(str)} + obj{cp(że)}
opatentować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
opatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
opatrzyć się: _: : perf: subj{np(str)} + {np(dat)}
opatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
opatulać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
opatulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opatulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
opatulać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
operacja: : : : {adjp(agr)} + {possp} + {prepnp(na,loc)}
operacja: : : : {adjp(agr)} + {possp} + {prepnp(przeciw,dat)} + {comprepnp(na rzecz)} + {xp(abl)} + {xp(adl); xp(locat)}
operacja: : : : {np(gen)} + {np(inst)} + {adjp(agr)} + {possp} + {prepnp(na,acc)}
operować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
operować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
operować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
operować: _: : imperf: subj{np(str)} + {xp(locat)}
opędzać się: _: : imperf: subj{np(str)} + {np(dat)}
opędzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
opędzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
opędzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
opędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
opędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
opędzić się: _: : perf: subj{np(str)} + {np(dat)}
opędzić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
opędzić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
opędzić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
opędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
opędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
opiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
opiąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opiąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
opić się: _: : perf: subj{np(str)} + {np(gen)}
opić się: _: : perf: subj{np(str)} + {np(inst)}
opić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opieczętować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opieka: : : : {possp} + {comprepnp(w sprawie)}
opieka: : : : {possp} + {comprepnp(w stosunku do)}
opieka: : : : {possp} + {prepnp(co do,gen)}
opieka: : : : {possp} + {prepnp(dla,gen)}
opieka: : : : {possp} + {prepnp(nad,inst)}
opieka: : : : {possp} + {prepnp(wobec,gen)}
opieka: : : : {possp} + {prepnp(względem,gen)}
opiekować się: _: : imperf: subj{np(str)} + {np(inst)}
opierać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
opierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
opierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
opierać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
opierać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
opierać się: _: : imperf: subj{np(str)} + {xp(locat)}
opierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
opierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
opiewać: _: : imperf: subj{np(str)} + obj{np(str)}
opiewać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
opijać się: _: : imperf: subj{np(str)} + {np(gen)}
opijać się: _: : imperf: subj{np(str)} + {np(inst)}
opijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opinać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
opinać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
opinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opinać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
opiniować: _: : imperf: subj{np(str)} + {cp(int)}
opiniować: _: : imperf: subj{np(str)} + {cp(że)}
opiniować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
opiniować: _: : imperf: subj{np(str)} + {or}
opisać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
opisać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
opisać: _: : perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)}
opisywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
opisywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
opisywać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)}
oplatać się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
oplatać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
opleść się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
opleść: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opleść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
oplotkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
oplotkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
oplotkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oplotkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
oplotkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
oplotkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
opluć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opluć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
opluć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opluć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
opluwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
opluwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
opluwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opluwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
opłacać się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
opłacać się: _: : imperf: subj{cp(żeby)} + {np(dat)}
opłacać się: _: : imperf: subj{np(str)} + {np(dat)}
opłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opłacić się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
opłacić się: _: : perf: subj{cp(żeby)} + {np(dat)}
opłacić się: _: : perf: subj{np(str)} + {np(dat)}
opłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opłakiwać: _: : imperf: subj{np(str)} + obj{np(str)}
opłata: : : : {adjp(agr)} + {possp} + {prepnp(na,acc); prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {prepnp(od,gen)} + {prepnp(w,loc)} + {comprepnp(na rzecz)} + {lexnp(inst,sg,'tytuł',atr); preplexnp(z,gen,sg,'tytuł',atr)} + {preplexnp(w,loc,sg,'kwota',atr); preplexnp(w,loc,sg,'wysokość',atr)}
opłata: : : : {adjp(agr); prepnp(od,gen); prepnp(za,acc); preplexnp(z,gen,sg,'tytuł',atr)}
opłata: : : : {cp(żeby)}
opłata: : : : {np(gen)} + {prepnp(w,loc)} + {prepnp(za,acc)} + {comprepnp(na rzecz)} + {preplexnp(w,loc,sg,'wysokość',atr)}
opłata: : : : {np(inst)} + {prepnp(za,acc)}
opłukać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
opłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
opłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
opłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
opłukać: _: : perf: subj{np(str)} + {prepnp(pod,inst)} + {refl}
opłukać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
opłukać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
oponować: _: : imperf: subj{np(str)} + {cp(jakoby)}
oponować: _: : imperf: subj{np(str)} + {cp(że)}
oponować: _: : imperf: subj{np(str)} + {cp(żeby)}
oponować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
oponować: _: : imperf: subj{np(str)} + {or}
oponować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,jakoby); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
oporządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
oporządzać: _: : imperf: subj{np(str)} + {refl}
oporządzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
oporządzić: _: : perf: subj{np(str)} + {refl}
opowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
opowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
opowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
opowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
opowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {nonch}
opowiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
opowiadać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
opowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
opowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
opowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
opowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
opowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {nonch}
opowiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opowiedzieć: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
opowieść: : : : {possp} + {comprepnp(na temat)}
opowieść: : : : {possp} + {cp(int)}
opowieść: : : : {possp} + {cp(jakoby)}
opowieść: : : : {possp} + {cp(że)}
opowieść: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)}
opowieść: : : : {possp} + {prepnp(wokół,gen)}
opozycyjny: : : : {comprepnp(w stosunku do)}
opozycyjny: : : : {prepnp(dla,gen)}
opozycyjny: : : : {prepnp(do,gen)}
opozycyjny: : : : {prepnp(wobec,gen)}
opozycyjny: : : : {prepnp(względem,gen)}
opóźniać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opóźniać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {comprepnp(z powodu)}
opóźniać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
opóźniać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
opóźniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opóźnić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opóźnić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {comprepnp(z powodu)}
opóźnić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
opóźnić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
opóźnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opracować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opracować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
opracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
opracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
oprawny: : : : {prepnp(w,acc)}
opromieniać się: _: : imperf: subj{np(str)} + {np(inst)}
opromieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opromienić się: _: : perf: subj{np(str)} + {np(inst)}
opromienić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
oprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
opróżniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
opróżniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
opróżnić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
opróżnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oprzeć się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
oprzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
oprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
oprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
oprzeć się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
oprzeć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
oprzeć się: _: : perf: subj{np(str)} + {xp(locat)}
oprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
oprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
optować: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
optować: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
opublikować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
opuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
opuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
opustoszeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
orać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
orać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
orać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
ordynować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
organizować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
organizować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
organizować się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
organizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
organizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
organizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
organizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
orientować się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
orientować się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
orientować się: _: : imperf: subj{np(str)} + {cp(int)}
orientować się: _: : imperf: subj{np(str)} + {cp(że)}
orientować się: _: : imperf: subj{np(str)} + {or}
orientować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
orientować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
orientować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
orientować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
orientować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
orientować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
orientować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
orientować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
orzec: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
orzec: _: : perf: subj{np(str)} + {cp(int)}
orzec: _: : perf: subj{np(str)} + {cp(że)}
orzec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
orzec: _: : perf: subj{np(str)} + {or}
orzec: _: : perf: subj{np(str)} + {prepnp(co do,gen)}
orzec: _: : perf: subj{np(str)} + {prepnp(na,acc)}
orzec: _: : perf: subj{np(str)} + {prepnp(o,loc)}
orzekać: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
orzekać: _: : imperf: subj{np(str)} + {cp(int)}
orzekać: _: : imperf: subj{np(str)} + {cp(że)}
orzekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
orzekać: _: : imperf: subj{np(str)} + {or}
orzekać: _: : imperf: subj{np(str)} + {prepnp(co do,gen)}
orzekać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
orzekać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
osądzać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
osądzać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
osądzać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
osądzać: _: : imperf: subj{np(str)} + {cp(int)}
osądzać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
osądzać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
osądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
osądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
osądzać: _: : imperf: subj{np(str)} + {or}
osądzić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
osądzić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
osądzić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
osądzić: _: : perf: subj{np(str)} + {cp(int)}
osądzić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
osądzić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
osądzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
osądzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
osądzić: _: : perf: subj{np(str)} + {or}
oscylować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
oscylować: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
oscylować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
oscylować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
oscylować: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
oscylować: _: : imperf: subj{np(str)} + {xp(adl)}
osiadać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
osiadły: : : : {xp(locat)} + {xp(temp)}
osiągać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
osiągnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
osiąść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
osiedlać się: _: : imperf: subj{np(str)} + {xp(locat)}
osiedlać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
osiedlić się: _: : perf: subj{np(str)} + {xp(locat)}
osiedlić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
osierocić: _: : perf: subj{np(str)} + obj{np(str)}
osiodłać: _: : perf: subj{np(str)} + obj{np(str)}
osiwieć: _: : perf: subj{np(str)} + {np(dat)}
osiwieć: _: : perf: subj{np(str)} + {xp(locat)}
oskarżać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
oskarżać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oskarżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(wobec,gen)}
oskarżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or}
oskarżać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or} + {refl}
oskarżyć: _: : perf: subj{np(str)} + {cp(że)} + {refl}
oskarżyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
oskarżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(wobec,gen)}
oskarżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or}
oskarżyć: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or} + {refl}
oskrobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oskrobywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oskrobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oskubać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oskubać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oskubać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oskubywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
osłabiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
osłabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
osłabić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
osłabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
osłabnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
osłabnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
osłabnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
osłaniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
osłaniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
osłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
osłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
osłonić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
osłonić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
osłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
osłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
osłupieć: _: : perf: subj{np(str)} + {cp(że)}
osłupieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
osmalić się: _: : perf: subj{np(str)}
osmalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osowieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
ostać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ostać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
ostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ostać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
ostemplować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ostrzec: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
ostrzec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepnp(przed,inst); prepncp(o,loc,że); prepncp(przed,inst,że)}
ostrzec: _: : perf: subj{np(str)} + {or}
ostrzegać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
ostrzegać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepnp(przed,inst); prepncp(o,loc,że); prepncp(przed,inst,że)}
ostrzegać: _: : imperf: subj{np(str)} + {or}
ostrzelać się: _: : perf: subj{np(str)}
ostrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ostrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ostrzeliwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ostrzeliwać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ostrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ostrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ostrzyc się: _: : perf: subj{np(str)} + {xp(locat)} + {advp(misc)}
ostrzyc: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
ostrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
ostrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ostrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ostrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ostrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
ostudzać się: _: : imperf: subj{np(str)} + {xp(locat)}
ostudzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
ostudzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ostudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ostudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
ostudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ostudzić się: _: : perf: subj{np(str)} + {xp(locat)}
ostudzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
ostudzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ostudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ostudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
ostudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
osunąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
osunąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
osunąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
osunąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
osunąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
osunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
osuszać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
osuszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
osuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
osuszyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
osuszyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
osuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
osuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
osuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
osuwać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
osuwać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
osuwać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
osuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
oswajać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
oswajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
oswoić się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
oswoić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
oszacować: _: : perf: subj{np(str)} + {cp(int)}
oszacować: _: : perf: subj{np(str)} + {cp(że)}
oszacować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
oszacować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
oszacować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oszacować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oszaleć: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
oszaleć: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
oszaleć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
oszaleć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
oszaleć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
oszczędzać: _: : imperf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
oszczędzać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
oszczędzać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
oszczędzać: _: : imperf: subj{np(str)} + {refl}
oszczędzić: _: : perf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
oszczędzić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
oszczędzić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
oszczędzić: _: : perf: subj{np(str)} + {refl}
oszkalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)}
oszkalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
oszkalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
oszklić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oszlifować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oszpecać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oszpecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oszpecić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oszpecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oszukać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
oszukać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
oszukać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
oszukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oszukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oszukiwać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
oszukiwać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
oszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
oślepiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oślepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oślepić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oślepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ośmielać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
ośmielać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
ośmielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ośmielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ośmielić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
ośmielić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
ośmielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ośmielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ośnieżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ośnieżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oświadczać się: _: : imperf: subj{np(str)} + {np(dat)}
oświadczać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
oświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
oświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
oświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
oświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
oświadczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
oświadczyć się: _: : perf: subj{np(str)} + {np(dat)}
oświadczyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
oświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
oświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
oświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
oświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
oświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
oświadczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
oświecać: _: : imperf: subj{cp(int)} + {np(str)}
oświecać: _: : imperf: subj{cp(że)} + {np(str)}
oświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
oświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
oświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
oświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
oświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
oświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oświecić: _: : perf: subj{cp(int)} + {np(str)}
oświecić: _: : perf: subj{cp(że)} + {np(str)}
oświecić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
oświecić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
oświecić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
oświecić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
oświecić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
oświecić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
oświecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oświetlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oświetlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otaczać się: _: : imperf: subj{np(str)} + {np(inst)}
otaczać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
otaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
otaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
otaksować: _: : perf: subj{np(str)} + {cp(że)}
otaksować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otaksować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
otoczyć się: _: : perf: subj{np(str)} + {np(inst)}
otoczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
otoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
otropić: _: : perf: subj{np(str)} + obj{np(str)}
otruć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
otruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otrząsać się: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)}
otrząsać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
otrząsać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otrząsnąć się: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)}
otrząsnąć się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
otrząsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
otrzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
otrzeć się: _: : perf: subj{np(str)} + {xp(locat)}
otrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
otrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
otrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
otrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
otrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
otrzepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
otrzepać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
otrzepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
otrzepywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
otrzeźwiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
otrzeźwiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
otrzeźwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
otrzeźwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otrzeźwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
otrzeźwiać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
otrzeźwiać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
otrzeźwić: _: : perf: {np(str)} + {cp(że)}
otrzeźwić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
otrzeźwić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
otrzeźwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otrzeźwić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otrzeźwić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
otrzeźwić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
otrzeźwić: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
otrzeźwieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
otrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
otrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
otrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otulać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
otulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
otulać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
otulić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
otulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
otulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
otulić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
otworzyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
otworzyć się: _: : perf: subj{np(str)} + {np(dat)}
otworzyć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
otworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
otworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
owdowieć: _: : perf: subj{np(str)}
owiać: _: : perf: {np(str)}
owiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owijać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
owijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
owijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owijać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
owinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owinąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
owinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
owinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owinąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
owocować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
ozdabiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ozdabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozdabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ozdabiać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ozdobić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ozdobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozdobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ozdobić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
oznaczać: _: : imperf: subj,controller{infp(_)} + controllee{infp(_)}
oznaczać: _: : imperf: subj{np(str)} + {cp(int)}
oznaczać: _: : imperf: subj{np(str)} + {np(str); ncp(str,że)} + {prepnp(dla,gen)}
oznaczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
oznaczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
oznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
oznaczać: _: : imperf: subj{np(str)} + {or}
oznaczać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {cp(że)}
oznaczyć: _: : perf: subj{np(str)} + {cp(że)}
oznaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
oznaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
oznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
oznajmiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
oznajmiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że); cp(żeby)}
oznajmiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
oznajmiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
oznajmiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
oznajmić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
oznajmić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że); cp(żeby)}
oznajmić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
oznajmić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
oznajmić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
oznakować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oznakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozwać się: _: : perf: subj{np(str)} + {np(inst)} + {or}
ozwać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(mod)} + {or}
ozwać się: _: : perf: subj{np(str)} + {xp(locat)} + {xp(mod)} + {or}
ożenić się: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
ożenić się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
ożenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
ożyć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
ożywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
ożywiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
ożywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ożywić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
ożywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pachnąć: _: : imperf: controller{np(dat)} + controllee{infp(_)}
pachnąć: _: : imperf: controller{xp(locat)} + controllee{xp(mod)}
pachnąć: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)}
pachnąć: _: : imperf: {np(dat)} + {xp(abl)} + {xp(mod)}
pachnąć: _: : imperf: {np(inst)} + {xp(locat)}
pachnąć: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
pachnąć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pachnąć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnąć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pachnieć: _: : imperf: controller{np(dat)} + controllee{infp(_)}
pachnieć: _: : imperf: controller{xp(locat)} + controllee{xp(mod)}
pachnieć: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)}
pachnieć: _: : imperf: {np(dat)} + {xp(abl)} + {xp(mod)}
pachnieć: _: : imperf: {np(inst)} + {xp(locat)}
pachnieć: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
pachnieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pachnieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pacnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
pacnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pacnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
pacnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pacnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pacnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
paczkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
paczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
paczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
paczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
padać: _: : imperf: subj{cp(żeby)} + {prepnp(na,acc)}
padać: _: : imperf: subj{E} + {np(dat)} + {xp(adl)}
padać: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
padać: _: : imperf: subj{np(str)} + {lexnp(inst,_,'ofiara',ratr)}
padać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'łup',ratr)}
padać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'pastwa',ratr)}
padać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'trup',natr)}
padać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
padać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
padać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
padać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
padać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
padać: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
padać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
padać: _: : imperf: subj{np(str)} + {xp(adl)} + {lexnp(inst,sg,'placek',natr)}
pakować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
pakować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
pakować się: _: : imperf: subj{np(str)} + {xp(adl)}
pakować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pakować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pakować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pakować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
paktować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
paktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
paktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
paktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
paktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
palić się: _: : imperf: {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
palić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
palić się: _: : imperf: subj{E} + {xp(locat)}
palić się: _: : imperf: subj{np(str)} + {cp(żeby)}
palić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,pl,'noga',natr)}
palić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,pl,'stopa',natr)}
palić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'ręka',natr)}
palić się: _: : imperf: subj{np(str)} + {np(inst)}
palić się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
palić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
palić: _: : imperf: {np(str)} + {xp(locat)}
palić: _: : imperf: subj{cp(żeby)} + {np(str)}
palić: _: : imperf: subj{np(str)} + {lexnp(str,pl,'most',atr)} + {preplexnp(za,inst,_,'siebie',natr)}
palić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
palić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
palić: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
palić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
palić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
palić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'popiół',natr)}
palnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
palnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
palnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
palnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
palnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
palnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
palnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
palnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
palnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
palnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
palnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
palnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
palnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
pałętać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
pałętać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
pamięć: : : : {np(gen); ncp(gen,int); ncp(gen,że)} + {possp}
pamięć: : : : {possp} + {comprepnp(na temat)}
pamięć: : : : {possp} + {comprepnp(w kwestii)}
pamięć: : : : {possp} + {comprepnp(w sprawie)}
pamięć: : : : {possp} + {cp(że)}
pamięć: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
pamięć: : : : {possp} + {prepnp(dla,gen)}
pamięć: : : : {possp} + {prepnp(do,gen)}
pamięć: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
pamiętać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
pamiętać: _: : imperf: subj{np(str)} + {cp(żeby)}
pamiętać: _: : imperf: subj{np(str)} + {np(str); cp(int); cp(jak); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2)}
pamiętać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
pamiętać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
pamiętać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pamiętać: _: : imperf: subj{np(str)} + obj{np(str)}
pamiętać: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(int); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pan: : : : {fixed('dzieju')}
pan: : : : {fixed('ładny')}
pan: : : : {fixed('młody')}
pan: : : : {fixed('mocium')}
pan: : : : {fixed('starszy')}
pan: : : : {fixed('udzielny')}
pan: : : : {fixed('życia i śmierci')}
pan: : : : {lexnp(agr,sg,'władza',natr)}
pan: : : : {possp} + {prepnp(od,gen)}
pan: : : : {preplexnp(na,loc,pl,'włość',natr)}
pani: : : : {fixed('młoda')}
pani: : : : {lexnp(gen,sg,'dom',atr)}
pani: : : : {lexnp(gen,sg,'serce',atr)}
pani: : : : {possp} + {prepnp(od,gen)}
panikować: _: : imperf: subj{np(str)} + {cp(że)}
panikować: _: : imperf: subj{np(str)} + {or}
panoszyć się: _: : imperf: subj{np(str)} + {xp(locat)}
panować: _: : imperf: subj{np(str)} + {np(dat)}
panować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
panować: _: : imperf: subj{np(str)} + {xp(locat)}
panować: _: : imperf: subj{np(str)} + {xp(temp)}
parać się: _: : imperf: subj{np(str)} + {np(inst)}
paradować: _: : imperf: subj{np(str)} + {xp(locat)}
paradować: _: : imperf: subj{np(str)} + {xp(perl)}
parafować: _: : _: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
parafować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
paraliżować: _: : imperf: {np(str)}
paraliżować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
paraliżować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
parkować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
parkować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
parować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
parować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(perl)}
parować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
parować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
partner: : : : {comprepnp(w stosunku do)}
partner: : : : {np(gen)} + {possp}
partner: : : : {possp} + {prepnp(do,gen); prepnp(w,loc); prepncp(do,gen,żeby)}
partner: : : : {possp} + {xp(locat)}
partner: : : : {prepnp(wobec,gen)}
partner: : : : {prepnp(względem,gen)}
partycypować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
parzyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
parzyć się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
parzyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
parzyć: _: : imperf: subj{E} + {np(str)}
parzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
parzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
parzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pasać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pasjonować się: _: : imperf: subj{np(str)} + {cp(int)}
pasjonować się: _: : imperf: subj{np(str)} + {cp(że)}
pasjonować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pasjonować: _: : imperf: subj{cp(int)} + {np(str)} + {prepnp(w,loc)}
pasjonować: _: : imperf: subj{cp(że)} + {np(str)} + {prepnp(w,loc)}
pasjonować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
pasować: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
pasować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pasować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
pasować: _: : imperf: subj{cp(int)} + {np(dat)}
pasować: _: : imperf: subj{cp(żeby)} + {np(dat)}
pasować: _: : imperf: subj{cp(że)} + {np(dat)}
pasować: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
pasować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pasować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(inst)}
pasożytować: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
pasożytować: _: : imperf: subj{np(str)} + {xp(locat)}
pastować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)} + {xp(locat)}
pastować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pastwić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
paść się: _: : imperf: subj{np(str)} + {np(inst)}
paść się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
paść: _: : perf: {np(dat)} + {prepnp(na,acc)}
paść: _: : perf: subj{cp(żeby)} + {prepnp(na,acc)}
paść: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
paść: _: : perf: subj{np(str)} + {lexnp(inst,_,'ofiara',ratr)}
paść: _: : perf: subj{np(str)} + {lexnp(inst,sg,'łup',ratr)}
paść: _: : perf: subj{np(str)} + {lexnp(inst,sg,'pastwa',ratr)}
paść: _: : perf: subj{np(str)} + {lexnp(inst,sg,'trup',natr)}
paść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
paść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
paść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
paść: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
paść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
paść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
paść: _: : perf: subj{np(str)} + {prepnp(od,gen)}
paść: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
paść: _: : perf: subj{np(str)} + {prepnp(z,gen)}
paść: _: : perf: subj{np(str)} + {xp(adl)} + {lexnp(inst,sg,'placek',natr)}
paść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
paść: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
patentować: _: : imperf: subj{np(str)} + obj{cp(int)}
patentować: _: : imperf: subj{np(str)} + obj{cp(że)}
patentować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
patrolować: _: : imperf: subj{np(str)} + {cp(czy)}
patrolować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
patronować: _: : imperf: subj{np(str)} + {np(dat)}
patroszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
patrzeć się: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
patrzeć się: _: : imperf: subj{np(str)} + {cp(int)}
patrzeć się: _: : imperf: subj{np(str)} + {cp(jak); cp(że)}
patrzeć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
patrzeć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
patrzeć się: _: : imperf: subj{np(str)} + {prepncp(na,acc,int)}
patrzeć się: _: : imperf: subj{np(str)} + {prepncp(na,acc,jak)}
patrzeć się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
patrzeć się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
patrzeć: _: : imperf: {np(dat)} + {advp(misc)} + {preplexnp(z,gen,pl,'oko',atr)}
patrzeć: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
patrzeć: _: : imperf: subj{np(str)} + {cp(int)}
patrzeć: _: : imperf: subj{np(str)} + {cp(jak)}
patrzeć: _: : imperf: subj{np(str)} + {cp(że)}
patrzeć: _: : imperf: subj{np(str)} + {cp(żeby)}
patrzeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(w,acc)}
patrzeć: _: : imperf: subj{np(str)} + {np(gen)}
patrzeć: _: : imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
patrzeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(czy)}
patrzeć: _: : imperf: subj{np(str)} + {prepnp(na,acc); cp(czy); cp(jak); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że)}
patrzeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
patrzeć: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
patrzeć: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
patrzeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
patrzyć się: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
patrzyć się: _: : imperf: subj{np(str)} + {cp(int)}
patrzyć się: _: : imperf: subj{np(str)} + {cp(jak)}
patrzyć się: _: : imperf: subj{np(str)} + {cp(że)}
patrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
patrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
patrzyć się: _: : imperf: subj{np(str)} + {prepncp(na,acc,int)}
patrzyć się: _: : imperf: subj{np(str)} + {prepncp(na,acc,jak)}
patrzyć się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
patrzyć się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
patrzyć: _: : imperf: {np(dat)} + {advp(misc)} + {preplexnp(z,gen,pl,'oko',atr)}
patrzyć: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
patrzyć: _: : imperf: subj{np(str)} + {cp(int)}
patrzyć: _: : imperf: subj{np(str)} + {cp(jak); cp(że)}
patrzyć: _: : imperf: subj{np(str)} + {cp(żeby)}
patrzyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(w,acc)}
patrzyć: _: : imperf: subj{np(str)} + {np(gen)}
patrzyć: _: : imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
patrzyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(czy)}
patrzyć: _: : imperf: subj{np(str)} + {prepnp(na,acc); cp(czy); cp(jak); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że)}
patrzyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
patrzyć: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
patrzyć: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
patrzyć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
patyczkować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pączkować: _: : imperf: subj{np(str)} + {np(inst)}
pączkować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
pączkować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pchać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
pchać się: _: : imperf: subj{np(str)} + {cp(żeby)}
pchać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pchać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pchać się: _: : imperf: subj{np(str)} + {prepncp(do,gen,żeby)}
pchać się: _: : imperf: subj{np(str)} + {prepnp(między,acc)}
pchać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
pchać się: _: : imperf: subj{np(str)} + {xp(adl)}
pchać: _: : imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
pchać: _: : imperf: subj{np(str)} + {np(str)} + {prepncp(do,gen,żeby)}
pchać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pchać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pchać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pchać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pchnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
pchnąć: _: : perf: subj{np(str)} + {np(str)} + {cp(żeby)}
pchnąć: _: : perf: subj{np(str)} + {np(str)} + {prepncp(do,gen,żeby)}
pchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pełgać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pełnić: _: : imperf: subj{np(str)} + obj{np(str)}
pełzać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pełzać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
pełznąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pełznąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
penetrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
perfekcyjny: : : : {prepnp(w,loc); prepncp(w,loc,int)}
perorować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
perorować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
perorować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
perorować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {nonch}
perorować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
perorować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
perorować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
perorować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pertraktować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
pertraktować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
pertraktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
pertraktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pertraktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
pertraktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
pertraktować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
peszyć się: _: : imperf: subj{np(str)} + {cp(int)}
peszyć się: _: : imperf: subj{np(str)} + {cp(że)}
peszyć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
peszyć się: _: : imperf: subj{np(str)} + {or}
peszyć: _: : imperf: subj{cp(gdy)} + {np(str)}
peszyć: _: : imperf: subj{cp(int)} + {np(str)}
peszyć: _: : imperf: subj{cp(jak)} + {np(str)}
peszyć: _: : imperf: subj{cp(jeśli)} + {np(str)}
peszyć: _: : imperf: subj{cp(kiedy)} + {np(str)}
peszyć: _: : imperf: subj{cp(że)} + {np(str)}
peszyć: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
peszyć: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
pękać: _: : imperf: subj{np(str)} + {cp(że)}
pękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pękać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'szew',natr)}
pękać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
pęknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pęknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pęknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pęknąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'szew',natr)}
pętać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
pętać się: _: : imperf: subj{np(str)} + {xp(perl)}
pętać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
pętać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pętać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
piastować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
piąć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,loc)}
piąć się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
piąć się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
piąć się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
pić: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
pić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pić: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,jak); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
pić: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
piec się: _: : imperf: subj{np(str)}
piec: _: : imperf: {np(str)} + {xp(locat)}
piec: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
piec: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
piec: _: : imperf: subj{np(str)} + obj{np(str)}
pieczętować się: _: : imperf: subj{np(str)} + {np(inst)}
pieczętować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pielęgnować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
pielęgnować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pielgrzymować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pielić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
pienić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pienić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
pienić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pienić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
pienić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pienić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
pienić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pienić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pieprzyć się: _: : imperf: {np(dat)} + {xp(locat)}
pieprzyć się: _: : imperf: subj{cp(int)} + {np(dat)}
pieprzyć się: _: : imperf: subj{cp(że)} + {np(dat)}
pieprzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pieprzyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
pieprzyć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
pieprzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pieprzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
pieprzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pieprzyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pieprzyć: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
pieprzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
pieprzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
pieprzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pieprzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pierdolić się: _: : imperf: {np(dat)} + {cp(int)}
pierdolić się: _: : imperf: {np(dat)} + {prepnp(w,loc)}
pierdolić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pierdolić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
pierdolić: _: : imperf: subj{cp(int)} + {np(str)}
pierdolić: _: : imperf: subj{cp(że)} + {np(str)}
pierdolić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
pierdolić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pierdolić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
pierdolić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pierdolić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pierdolić: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
pierdolić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
pierdolić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
pierdolić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pierdolić: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
pierwotny: : : : {comprepnp(w stosunku do)}
pierwotny: : : : {prepnp(dla,gen)}
pierwotny: : : : {prepnp(do,gen)}
pierwotny: : : : {prepnp(wobec,gen)}
pierwotny: : : : {prepnp(względem,gen)}
pierzchać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)} + {xp(adl)}
pierzchnąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)} + {xp(adl)}
pierzchnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pies: : : : {adjp(agr); prepnp(do,gen)} + {possp}
pies: : : : {possp} + {prepnp(na,acc)}
pies: : : : {possp} + {prepnp(od,gen)}
pieścić się: _: : imperf: subj{np(str)} + {np(inst)}
pieścić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pieścić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pieścić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pięknieć: _: : imperf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',atr)}
pięknieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
piętnować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
piętnować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
piętrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
piętrzyć się: _: : imperf: subj{np(str)} + {np(inst)}
piętrzyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
piętrzyć się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
piętrzyć się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
piętrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
piętrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
piętrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
piętrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pijać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
pijać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
pikietować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
pikietować: _: : imperf: subj{np(str)} + obj{np(str)}
pikietować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
pikietować: _: : imperf: subj{np(str)} + {xp(locat)}
pilnować się: _: : imperf: subj{np(str)} + {cp(int)}
pilnować się: _: : imperf: subj{np(str)} + {cp(żeby)}
pilnować się: _: : imperf: subj{np(str)} + {np(gen)}
pilnować: _: : imperf: subj{np(str)} + obj{np(gen)} + {cp(int); cp(żeby)}
pilnować: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
pilnować: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(przed,inst)}
pisać się: _: : imperf: subj,controller{np(str)} + controllee{np(nom)}
pisać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
pisać się: _: : imperf: subj{np(str)} + {xp(dur)}
pisać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{np(nom)}
pisać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
pisać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pisać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pisać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pisać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(o,loc)}
pisać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pisać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
pisać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pisać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pisać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
pisać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pisać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
pisać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pisać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
pisać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
pisać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pisać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {or}
pisnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pisnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
pisnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',natr)} + {or}
pisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
pisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
pisnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
piszczeć: _: : imperf: {np(dat)} + {xp(locat)}
piszczeć: _: : imperf: subj{np(str)} + {cp(że)}
piszczeć: _: : imperf: subj{np(str)} + {cp(żeby)}
piszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
piszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
piszczeć: _: : imperf: subj{np(str)} + {np(inst)}
piszczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
piszczeć: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(z,gen)} + {or}
piszczeć: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
piszczeć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
piszczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
pitrasić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pitrasić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
plamić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
plamić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
plamić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
plamić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
plamić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
planować: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
planować: _: : imperf: subj{np(str)} + {cp(int)}
planować: _: : imperf: subj{np(str)} + {cp(żeby)}
planować: _: : imperf: subj{np(str)} + obj{cp(że)}
planować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,acc)}
planować: _: : imperf: subj{np(str)} + {or}
plaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
plaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
plaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
plaskać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
plaskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
plaskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
plasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
plasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
plasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
plasnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
plasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
plasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
plasować się: _: : imperf: subj{np(str)} + {xp(locat)}
plasować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
plądrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
plądrować: _: : imperf: subj{np(str)} + {xp(locat)}
pląsać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
plątać się: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
plątać się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
plątać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
plątać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
plątać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
plątać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
plątać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
plątać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
plątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
plątać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
plątać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
plątać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pleć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
pleść się: _: : imperf: subj{np(str)}
pleść się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pleść: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pleść: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pleść: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pleść: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
pleść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pleść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
plotka: : : : {possp} + {comprepnp(na temat)}
plotka: : : : {possp} + {cp(int)}
plotka: : : : {possp} + {cp(jakoby)}
plotka: : : : {possp} + {cp(że)}
plotka: : : : {possp} + {cp(żeby)}
plotka: : : : {possp} + {or}
plotka: : : : {possp} + {prepnp(co do,gen)}
plotka: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)}
plotka: : : : {possp} + {prepnp(wokół,gen)}
plotkować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
plotkować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {cp(że)}
plotkować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
plotkować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pluć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pluć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
pluć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
pluć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
pluskać się: _: : imperf: subj{np(str)} + {xp(locat)}
pluskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
pluskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pluskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pluskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
pluskać: _: : imperf: subj{np(str)} + {xp(adl)}
pluskać: _: : imperf: subj{np(str)} + {xp(locat)}
plusnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
plusnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
plusnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
plusnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
plusnąć: _: : perf: subj{np(str)} + {xp(adl)}
plusnąć: _: : perf: subj{np(str)} + {xp(locat)}
płacić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
płacić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
płakać: _: : imperf: subj{np(str)} + {cp(int)}
płakać: _: : imperf: subj{np(str)} + {cp(że)}
płakać: _: : imperf: subj{np(str)} + {or}
płakać: _: : imperf: subj{np(str)} + {prepncp(nad,inst,że)}
płakać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
płakać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
płakać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
płakać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
płatać: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'figiel',atr)} + {np(dat)}
płatać: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'psikus',atr)} + {np(dat)}
płatać: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'żart',atr)} + {np(dat)}
płatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
płatnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
płatny: : : : {advp(misc)}
płatny: : : : {comprepnp(na rzecz)}
płatny: : : : {np(acc)}
płatny: : : : {np(inst)} + {xp(temp)}
płatny: : : : {preplexnp(w,loc,sg,'wysokość',atr)}
pławić się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
pławić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
płodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
płodzić: _: : imperf: subj{np(str)} + {refl}
płonąć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
płonąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
płonąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
płonąć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
płoszyć się: _: : imperf: subj{np(str)} + {cp(że)}
płoszyć się: _: : imperf: subj{np(str)} + {np(inst)}
płoszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
płukać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
płukać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
płukać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
płynąć: _: : imperf: subj{lexnp(str,sg,'krew',atr)} + {preplexnp(w,loc,pl,'żyła',ratr)}
płynąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
płynąć: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {prepnp(za,inst)}
płynąć: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
płynąć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
płynąć: _: : imperf: subj{np(str)} + {xp(locat)}
pływać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {prepnp(za,inst)}
pływać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pływać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
pływać: _: : imperf: subj{np(str)} + {xp(locat)}
pobałamucić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
pobałamucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pobałamucić: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pobandażować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pobandażować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pobawić się: _: : perf: subj{np(str)} + {cp(że)}
pobawić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pobawić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pobawić: _: : perf: subj{np(str)} + {np(str)}
pobekiwać: _: : imperf: subj{np(str)} + {cp(że)}
pobekiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pobić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
pobić: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('na kwaśne jabłko')}
pobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pobiec: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(do,gen)}
pobiec: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
pobiec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pobiec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
pobiec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pobiec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
pobiec: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
pobiedować: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {xp(locat)}
pobielać się: _: : imperf: subj{np(str)} + {np(inst)}
pobielać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
pobielać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
pobielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pobieleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pobieleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pobielić się: _: : perf: subj{np(str)} + {np(inst)}
pobielić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
pobielić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pobielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pobierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pobierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
pobierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pobierać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
poblednąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poblednąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poblednąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pobłażać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pobłażliwy: : : : {comprepnp(w stosunku do)}
pobłażliwy: : : : {prepnp(co do,gen)}
pobłażliwy: : : : {prepnp(dla,gen)}
pobłażliwy: : : : {prepnp(na,acc)}
pobłażliwy: : : : {prepnp(w,loc)}
pobłażliwy: : : : {prepnp(wobec,gen)}
pobłażliwy: : : : {prepnp(względem,gen)}
pobłądzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pobłądzić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pobłądzić: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pobłądzić: _: : perf: subj{np(str)} + {xp(perl)}
pobłąkać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pobłąkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pobłękitnieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pobłękitnieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pobłogosławić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pobłogosławić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pobłogosławić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
pobłogosławić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pobłogosławić: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
pobóść się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pobóść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pobóść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pobrać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pobrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pobrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pobrać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pobrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pobrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pobrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pobrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
pobryzgać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pobryzgać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pobrzękiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pobrzękiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pobrzękiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
pobrzmiewać: _: : imperf: subj{np(str)} + {np(inst)}
pobrzmiewać: _: : imperf: subj{np(str)} + {xp(locat)}
pobudować się: _: : perf: subj{np(str)} + {xp(locat)}
pobudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pobudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pobudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
pobudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pobudować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pobudzać się: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
pobudzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {cp(żeby)}
pobudzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pobudzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
pobudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
pobudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pobudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
pobudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
pobudzić się: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
pobudzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {cp(żeby)}
pobudzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pobudzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
pobudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
pobudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pobudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
pobudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
pobujać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pobujać się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
pobujać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pobujać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pobujać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
pobujać: _: : perf: {np(inst)}
pobujać: _: : perf: subj{np(str)} + {comprepnp(na temat)}
pobujać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pobujać: _: : perf: subj{np(str)} + {np(str)} + {cp(że)}
pobujać: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
pobujać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pobujać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pobujać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pobujać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pobujać: _: : perf: subj{np(str)} + {or}
pobujać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
pobuntować się: _: : perf: subj{np(str)} + {cp(że)}
pobuntować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pobuntować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
pobuntować: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {cp(żeby)}
pobuntować: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
pobuntować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
poburzyć się: _: : perf: subj{np(str)} + {cp(że)}
poburzyć się: _: : perf: subj{np(str)} + {or}
poburzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
poburzyć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że)}
poburzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
poburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
poburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
pobyt: : : : {possp} + {xp(dur)} + {xp(locat)}
pobyt: : : : {prepnp(przez,acc)} + {xp(dur)} + {xp(locat)}
pocałować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pocałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pocałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pocałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pocałować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {preplexnp(z,gen,sg,'dubeltówka',natr)}
pocałować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pocałować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pocerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pochlubić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
pochlubić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(wobec,gen)}
pochlubić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
pochlubić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
pochlubić się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(int)}
pochlubić się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
pochłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pochłonąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pochodny: : : : {comprepnp(w stosunku do)}
pochodny: : : : {prepnp(od,gen)} + {xp(mod)}
pochodny: : : : {prepnp(wobec,gen)}
pochodny: : : : {prepnp(względem,gen)}
pochodzić: _: : perf: subj{np(str)} + {prepnp(koło,gen)}
pochodzić: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pochodzić: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pochodzić: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pochodzić: _: : imperf: subj{np(str)} + {xp(abl)}
pochować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
pochować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pochować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
pochować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pochrapywać: _: : imperf: subj{np(str)} + {np(inst)}
pochrapywać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
pochwalać: _: : imperf: subj{np(str)} + {cp(że)}
pochwalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
pochwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pochwalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
pochwalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pochwalić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pochwalić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
pochwalić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
pochwalić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
pochwalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
pochwalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
pochwalić: _: : perf: subj{np(str)} + {np(str)} + {or}
pochwalić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
pochwalić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
pochwalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pochwycić: _: : perf: subj{np(str)} + {cp(int)}
pochwycić: _: : perf: subj{np(str)} + {cp(że)}
pochwycić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
pochwycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
pochwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
pochwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pochwycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pochwycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pochwycić: _: : perf: subj{np(str)} + {or}
pochwytać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
pochwytać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
pochwytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
pochwytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pochylać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
pochylać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
pochylać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
pochylać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,_,'głowa',natr)}
pochylać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(str,_,'głowa',natr)}
pochylić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
pochylić się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
pochylić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
pochylić: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,_,'głowa',natr)}
pochylić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(str,_,'głowa',natr)}
pociąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
pociąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pociąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepnp(w,acc)}
pociągać: _: : imperf: {np(inst)} + {xp(adl)}
pociągać: _: : imperf: subj{cp(żeby)} + {np(str)}
pociągać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',natr)}
pociągać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'nos',natr)} + {or}
pociągać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
pociągać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
pociągać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
pociągać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pociągać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
pociągać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
pociągać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {preplexnp(z,inst,_,'siebie',natr)}
pociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
pociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
pociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'odpowiedzialność',atr)}
pociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,acc,sg,'język',natr)}
pociągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pociągnąć: _: : perf: {np(inst)} + {xp(abl)}
pociągnąć: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',natr)}
pociągnąć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'nos',natr)} + {or}
pociągnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
pociągnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pociągnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
pociągnąć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {preplexnp(za,acc,sg,'język',natr)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)} + {preplexnp(za,acc,sg,'język',natr)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {preplexnp(za,inst,_,'siebie',natr)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'odpowiedzialność',atr)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pociągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(adl)}
pociągnąć: _: : perf: subj{np(str)} + {xp(dur)}
pocić się: _: : imperf: subj{np(str)} + {cp(żeby)}
pocić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pocić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pocić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
pocierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
pocierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {refl}
pocierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pocierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
pocierać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
pocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
pocierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pocierpnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pocierpnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pocieszać się: _: : imperf: subj{np(str)} + {cp(że)}
pocieszać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
pocieszać się: _: : imperf: subj{np(str)} + {or}
pocieszać: _: : imperf: subj{cp(że)} + {np(str)}
pocieszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
pocieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
pocieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
pocieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
pocieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pocieszyć się: _: : perf: subj{np(str)} + {cp(że)}
pocieszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
pocieszyć się: _: : perf: subj{np(str)} + {or}
pocieszyć: _: : perf: subj{cp(że)} + {np(str)}
pocieszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
pocieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
pocieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
pocieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
pocieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pocwałować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
począć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
począć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
począć: _: : perf: subj,controller{E} + controllee{infp(imperf)}
począć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
począć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {nonch}
poczekać: _: : perf: subj{np(str)} + {np(gen)}
poczekać: _: : perf: subj{np(str)} + {prepnp(na,acc); cp(aż); cp(int); cp(jak); cp(kiedy); cp(że); cp(żeby); prepncp(na,acc,aż); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)} + {xp(dur)}
poczekać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(aż)} + {xp(dur)}
poczekać: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
poczerniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poczernić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poczerwienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poczerwienieć: _: : perf: subj{np(str)} + {prepnp(po,acc)}
poczerwienieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poczęstować się: _: : perf: subj{np(str)} + {np(inst)}
poczęstować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poczołgać się: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,loc)}
poczołgać się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
poczołgać się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
poczubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
poczuć się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
poczuć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(na,loc,pl,'siła',natr)}
poczuć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
poczuć się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
poczuć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
poczuć się: _: : perf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
poczuć się: _: : perf: subj{np(str)} + {np(gen)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
poczuć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poczuć: _: : perf: subj{np(str)} + {cp(int)}
poczuć: _: : perf: subj{np(str)} + {cp(jak)}
poczuć: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',natr)}
poczuć: _: : perf: subj{np(str)} + {np(str); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że)}
poczuć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
poczuć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
poczuć: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
poczuwać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
poczuwać się: _: : imperf: subj{np(str)} + {cp(żeby)}
poczuwać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
poczuwać: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {xp(dur)}
poczuwać: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
poczynać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
poczynać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
poczynać: _: : imperf: controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
poczynać: _: : imperf: subj,controller{E} + controllee{infp(imperf)}
poczynać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poczynić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poczyścić się: _: : perf: subj{np(str)}
poczyścić: _: : perf: {np(str)}
poczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poczyścić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
poczytać: _: : perf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
poczytać: _: : perf: subj{np(str)} + controller{cp(żeby)} + controllee{prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
poczytać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
poczytać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
poczytać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
poczytać: _: : perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(jako,str)} + {np(dat)}
poczytać: _: : perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)} + {np(dat)}
poczytać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
poczytać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)} + {np(dat)}
poczytać: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)} + {np(dat)}
poczytać: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(za,acc)} + {np(dat)}
poczytać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
poczytać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poczytywać: _: : imperf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
poczytywać: _: : imperf: subj{np(str)} + controller{cp(żeby)} + controllee{prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
poczytywać: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(jako,str)} + {np(dat)}
poczytywać: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)} + {np(dat)}
poczytywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
poczytywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)} + {np(dat)}
poczytywać: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)} + {np(dat)}
poczytywać: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(za,acc)} + {np(dat)}
poćwiartować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
poćwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
podać się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(za,acc)}
podać się: _: : perf: subj,controller{np(str)} + controllee{prepnp(za,acc)}
podać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
podać: _: : perf: subj{np(str)} + {advp(pron)}
podać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
podać: _: : perf: subj{np(str)} + obj{cp(int)}
podać: _: : perf: subj{np(str)} + obj{cp(że)}
podać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
podać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'wątpliwość',natr)}
podać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
podać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
podać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podać: _: : perf: subj{np(str)} + {or}
podarować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
podatny: : : : {prepncp(na,acc,int)}
podatny: : : : {prepnp(do,gen); prepncp(do,gen,żeby)}
podatny: : : : {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
podawać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)}
podawać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)}
podawać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podawać: _: : imperf: subj{np(str)} + {advp(pron)}
podawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
podawać: _: : imperf: subj{np(str)} + obj{cp(int)}
podawać: _: : imperf: subj{np(str)} + obj{cp(że)}
podawać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
podawać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'wątpliwość',natr)}
podawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
podawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podawać: _: : imperf: subj{np(str)} + {or}
podąsać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
podąsać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
podąsać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
podąsać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podążać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst); prepncp(za,inst,int)}
podążać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podążać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
podążać: _: : imperf: subj{np(str)} + {xp(adl)}
podbić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
podbić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
podbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
podbić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
podbić: _: : perf: subj{np(str)} + {xp(adl)}
podbiec: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
podbiec: _: : perf: subj{np(str)} + {np(inst)}
podbiec: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)}
podbiegać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
podbiegać: _: : imperf: subj{np(str)} + {np(inst)}
podbiegać: _: : imperf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)}
podbijać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
podbijać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
podbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
podbijać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podbijać: _: : imperf: subj{np(str)} + {xp(adl)}
podburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
podburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
podchmielić się: _: : perf: subj{np(str)} + {np(inst)}
podchmielić: _: : perf: subj{np(str)} + {np(inst)} + {lexnp(dat,_,'siebie',natr)}
podchodzić: _: : imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
podchodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podchodzić: _: : imperf: subj{np(str)} + {np(inst)}
podchodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
podchodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
podchodzić: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podchodzić: _: : imperf: subj{np(str)} + {xp(adl)}
podchwycić: _: : perf: subj{np(str)} + {cp(int)}
podchwycić: _: : perf: subj{np(str)} + {cp(że)}
podchwycić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
podchwycić: _: : perf: subj{np(str)} + {or}
podchwytywać: _: : imperf: subj{np(str)} + {cp(int)}
podchwytywać: _: : imperf: subj{np(str)} + {cp(że)}
podchwytywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
podchwytywać: _: : imperf: subj{np(str)} + {or}
podciąć: _: : perf: {np(dat)} + {lexnp(str,pl,'noga',natr)}
podciąć: _: : perf: subj{cp(gdy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: _: : perf: subj{cp(jak)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: _: : perf: subj{cp(kiedy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podcieniować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podcinać: _: : imperf: {np(dat)} + {lexnp(str,pl,'noga',natr)}
podcinać: _: : imperf: subj{cp(gdy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: _: : imperf: subj{cp(jak)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: _: : imperf: subj{cp(kiedy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podczesać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
podczesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(mod)}
podczołgać się: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,loc)}
podczołgać się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
poddać się: _: : perf: subj{np(str)} + {np(dat)}
poddać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
poddać: _: : perf: subj{np(str)} + {or}
poddawać się: _: : imperf: subj{np(str)} + {np(dat)}
poddawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
poddawać: _: : imperf: subj{np(str)} + {or}
podejmować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
podejmować się: _: : imperf: subj{np(str)} + {cp(że)}
podejmować się: _: : imperf: subj{np(str)} + {cp(żeby)}
podejmować się: _: : imperf: subj{np(str)} + {np(gen)}
podejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podejmować: _: : imperf: subj{np(str)} + {or}
podejrzeć: _: : perf: subj{np(str)} + {cp(int)}
podejrzeć: _: : perf: subj{np(str)} + {cp(jak)}
podejrzeć: _: : perf: subj{np(str)} + {cp(że)}
podejrzeć: _: : perf: subj{np(str)} + obj{np(str)}
podejrzenie: : : : {np(gen); ncp(gen,że)} + {possp}
podejrzenie: : : : {possp} + {comprepnp(co do); prepncp(co do,gen,int); prepncp(co do,gen,że)}
podejrzenie: : : : {possp} + {comprepnp(na temat)}
podejrzenie: : : : {possp} + {comprepnp(w kwestii)}
podejrzenie: : : : {possp} + {comprepnp(w sprawie)}
podejrzenie: : : : {possp} + {or}
podejrzenie: : : : {possp} + {prepnp(o,acc); comprepnp(w sprawie); prepncp(o,acc,int); prepncp(o,acc,jakoby); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do)}
podejrzenie: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,że)}
podejrzenie: : : : {possp} + {prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do)} + {cp(int)}
podejrzenie: : : : {possp} + {prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do)} + {cp(jakoby)}
podejrzenie: : : : {possp} + {prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do)} + {cp(że)}
podejrzenie: : : : {possp} + {prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do)} + {cp(żeby)}
podejrzewać: _: : imperf: subj{np(str)} + {cp(int)}
podejrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
podejrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby2)}
podejrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby2)}
podejrzliwy: : : : {comprepnp(w stosunku do)}
podejrzliwy: : : : {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
podejrzliwy: : : : {prepnp(wobec,gen); prepncp(wobec,gen,że)}
podejrzliwy: : : : {prepnp(względem,gen)}
podejść: _: : perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
podejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podejść: _: : perf: subj{np(str)} + {np(inst)}
podejść: _: : perf: subj{np(str)} + {np(str)}
podejść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
podejść: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podejść: _: : perf: subj{np(str)} + {xp(adl)}
podekscytować się: _: : perf: subj{np(str)} + {cp(int)}
podekscytować się: _: : perf: subj{np(str)} + {cp(że)}
podekscytować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podekscytować się: _: : perf: subj{np(str)} + {or}
podekscytować: _: : perf: subj{cp(int)} + {np(str)}
podekscytować: _: : perf: subj{cp(że)} + {np(str)}
podekscytować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
podekscytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podenerwować się: _: : perf: subj{np(str)} + {cp(int)}
podenerwować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podenerwować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
podenerwować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
podenerwować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podenerwować się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
podenerwować: _: : perf: subj{cp(gdy)} + {np(str)}
podenerwować: _: : perf: subj{cp(int)} + {np(str)}
podenerwować: _: : perf: subj{cp(jak)} + {np(str)}
podenerwować: _: : perf: subj{cp(jeśli)} + {np(str)}
podenerwować: _: : perf: subj{cp(kiedy)} + {np(str)}
podenerwować: _: : perf: subj{cp(że)} + {np(str)}
podenerwować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
podenerwować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podeprzeć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
podeprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
podeprzeć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
podeprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podeprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
podeprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podeprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
poderwać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poderwać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poderwać się: _: : perf: subj{np(str)} + {xp(abl)}
poderwać się: _: : perf: subj{np(str)} + {xp(adl)}
poderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
poderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
poderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
poderwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
poderwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
poderżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podetkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podfrunąć: _: : perf: subj{np(str)} + {xp(adl)}
podfruwać: _: : imperf: subj{np(str)} + {xp(adl)}
podgajać się: _: : imperf: subj{np(str)} + {np(dat)}
podgajać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
podgajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podgalać: _: : imperf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
podgalać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podgalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
podgalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podganiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
podganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podgarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podgarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podgiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podglądać: _: : imperf: subj{np(str)} + {cp(int)}
podglądać: _: : imperf: subj{np(str)} + {cp(jak)}
podglądać: _: : imperf: subj{np(str)} + {cp(że)}
podglądać: _: : imperf: subj{np(str)} + obj{np(str)}
podgoić się: _: : perf: subj{np(str)} + {np(dat)}
podgoić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
podgoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podgolić: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
podgolić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podgolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
podgolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podgonić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
podgonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
podgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
podgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
podgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
podhodować się: _: : perf: subj{np(str)}
podhodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podhodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
podhodować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podjadać: _: : imperf: subj{np(str)} + {np(inst)}
podjadać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
podjąć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
podjąć się: _: : perf: subj{np(str)} + {cp(że)}
podjąć się: _: : perf: subj{np(str)} + {cp(żeby)}
podjąć się: _: : perf: subj{np(str)} + {np(gen)}
podjąć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'rękawica',atr)}
podjąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podjąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podjąć: _: : perf: subj{np(str)} + {or}
podjechać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podjechać: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
podjechać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podjechać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)}
podjechać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
podjechać: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
podjechać: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
podjechać: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podjeść: _: : perf: subj{np(str)} + {np(inst)}
podjeść: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
podjeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
podjeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podjeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
podjeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podjeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)}
podjeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
podjeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
podjeżdżać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
podjeżdżać: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podkładać się: _: : imperf: subj{np(str)} + {np(dat)}
podkładać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
podkładać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(pod,acc)}
podkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podkochiwać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
podkołować: _: : perf: subj{np(str)} + {xp(adl)}
podkradać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podkradać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
podkradać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podkraść się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podkraść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
podkraść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podkreślać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
podkreślać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
podkreślać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
podkreślać: _: : imperf: subj{np(str)} + {or}
podkreślić: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
podkreślić: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
podkreślić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
podkreślić: _: : perf: subj{np(str)} + {or}
podkręcać się: _: : imperf: subj{np(str)} + {np(inst)}
podkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podkręcić się: _: : perf: subj{np(str)} + {np(inst)}
podkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podkuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podkulać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podkulać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkulić się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podkulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkurczyć się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podkurczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkusić: _: : perf: subj,controllee{infp(_)} + controller{np(str)}
podkusić: _: : perf: subj{cp(żeby)} + {np(str)}
podkusić: _: : perf: subj{cp(że)} + {np(str)}
podkusić: _: : perf: subj{np(str)} + controller{np(str)} + controllee{infp(_)}
podkusić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
podkusić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podkusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podkuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podlegać: _: : imperf: subj{cp(int)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: _: : imperf: subj{cp(że)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: _: : imperf: subj{np(str)} + {np(dat)}
podległy: : : : {comprepnp(w stosunku do)}
podległy: : : : {np(dat)}
podległy: : : : {prepnp(dla,gen)}
podległy: : : : {prepnp(pod,acc)}
podległy: : : : {prepnp(wobec,gen)}
podległy: : : : {prepnp(względem,gen)}
podlepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podlepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
podlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(pod,acc)}
podlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(pod,acc)}
podlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
podlepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podlepić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
podlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(pod,acc)}
podlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(pod,acc)}
podlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
podlewać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
podlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podłączać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłączyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłożyć się: _: : perf: subj{np(str)} + {np(dat)}
podłożyć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
podłożyć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(pod,acc)}
podłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podłużać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podłużać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podłużyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podłużyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podmiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podmieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podminować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podminować: _: : perf: subj{cp(gdy)} + {np(str)}
podminować: _: : perf: subj{cp(int)} + {np(str)}
podminować: _: : perf: subj{cp(jak)} + {np(str)}
podminować: _: : perf: subj{cp(kiedy)} + {np(str)}
podminować: _: : perf: subj{cp(że)} + {np(str)}
podminować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
podminować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podminowywać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podminowywać: _: : imperf: subj{cp(gdy)} + {np(str)}
podminowywać: _: : imperf: subj{cp(int)} + {np(str)}
podminowywać: _: : imperf: subj{cp(jak)} + {np(str)}
podminowywać: _: : imperf: subj{cp(kiedy)} + {np(str)}
podminowywać: _: : imperf: subj{cp(że)} + {np(str)}
podminowywać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
podminowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podmyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
podmyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podmywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
podmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podnieść się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
podnieść się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
podnieść się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
podnieść się: _: : perf: subj{np(str)} + {xp(abl)}
podnieść: _: : perf: subj{np(str)} + {cp(że)}
podnieść: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'duch',natr)}
podnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
podnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podnieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
podnieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podobać się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
podobać się: _: : imperf: {np(dat)} + {xp(locat)}
podobać się: _: : imperf: subj{cp(gdy); ncp(str,gdy)} + {np(dat)}
podobać się: _: : imperf: subj{cp(jak); ncp(str,jak); xp(locat)} + {np(dat)}
podobać się: _: : imperf: subj{np(str); cp(jak); cp(że); ncp(str,jak); ncp(str,że)} + {np(dat)}
podobny: : : : {np(dat)} + {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)}
podobny: : : : {prepnp(do,gen)} + {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)}
podobny: : : : {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)} + {comp(co)}
podobny: : : : {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)} + {comp(jak)}
podobny: : : : {prepnp(w,loc); prepnp(z,gen); xp(mod); preplexnp(pod,inst,sg,'wzgląd',atr)} + {prepnp(z,inst)}
podoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podoić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podoić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podoić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
podoić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podołać: _: : perf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
podorabiać się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {np(inst); ncp(inst,że)}
podorabiać się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
podorabiać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
podorabiać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
podorastać: _: : perf: subj{np(str)} + {cp(żeby)}
podorastać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'pięta',natr)}
podorastać: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {advp(misc)}
podorastać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
podorastać: _: : perf: subj{np(str)} + {xp(locat)}
podostawać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
podostawać: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
podostawać: _: : perf: subj{np(str)} + {np(gen)}
podostawać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
podostawać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
podostawać: _: : perf: subj{np(str)} + {np(part)} + {prepnp(od,gen)}
podpadać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podpadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podpadać: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podpadać: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
podpalać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
podpalać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podpalać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
podpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podpalić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
podpalić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
podpalić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
podpalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podpasać się: _: : imperf: subj{np(str)} + {np(inst)}
podpasać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
podpasać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podpasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podpasywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podpasywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podpaść się: _: : perf: subj{np(str)} + {np(inst)}
podpaść się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
podpaść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podpaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podpaść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podpaść: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podpaść: _: : perf: subj{np(str)} + {prepnp(u,gen)}
podpatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podpatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podpatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
podpatrywać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(int)}
podpatrywać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
podpatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podpatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podpatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
podpatrzyć: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(int)}
podpatrzyć: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
podpierać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
podpierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
podpierać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
podpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
podpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
podpiłować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podpiłowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podpisać się: _: : perf: subj,controller{np(str)} + controllee{np(str)} + {prepnp(na,loc)}
podpisać się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)}
podpisać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
podpisać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(pod,inst); prepncp(pod,inst,że); prepncp(pod,inst,żeby)}
podpisać się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
podpisać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{np(str)}
podpisać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{prepnp(jako,str)} + {np(inst)}
podpisać: _: : perf: subj{np(str)} + obj{cp(że)}
podpisać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podpisywać się: _: : imperf: subj,controller{np(str)} + controllee{np(str)} + {prepnp(na,loc)}
podpisywać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)}
podpisywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
podpisywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,inst); prepncp(pod,inst,że); prepncp(pod,inst,żeby)}
podpisywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
podpisywać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{np(str)}
podpisywać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{prepnp(jako,str)} + {np(inst)}
podpisywać: _: : imperf: subj{np(str)} + obj{cp(że)}
podpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podpłacić: _: : perf: subj{np(str)} + {np(dat)}
podpłacić: _: : perf: subj{np(str)} + obj{np(str)}
podpłynąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(perl)}
podpłynąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)} + {xp(perl)}
podpływać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(perl)}
podpływać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)} + {xp(perl)}
podporządkować się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
podporządkować się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
podporządkować się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podporządkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podporządkowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
podporządkowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
podporządkowywać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podporządkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
podpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
podpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
podpowiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
podpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
podpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
podpowiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrałować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podrapać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
podrapać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
podrapać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
podrapać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
podrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
podrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
podrapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
podrastać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
podrastać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podreptać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
podreptać: _: : perf: subj{np(str)} + {prepnp(za,inst)}
podreptać: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podręcznik: : : : {np(gen)} + {possp} + {prepnp(dla,gen); prepnp(do,gen)}
podręcznik: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen)} + {comprepnp(na temat)}
podręcznik: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen)} + {prepnp(do,gen)}
podręcznik: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen)} + {prepnp(od,gen)}
podręcznik: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int)}
podręcznik: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen)} + {prepnp(z,gen)}
podręcznik: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen)} + {prepnp(z,inst)}
podrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
podrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podrożeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
podrożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podróżować: _: : perf: subj{np(str)} + obj{np(str)}
podróżować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
podróżować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podróżować: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
podróżować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
podrywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
podrywać się: _: : imperf: subj{np(str)} + {xp(abl)}
podrywać się: _: : imperf: subj{np(str)} + {xp(adl)}
podrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
podrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
podrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
podrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
podrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podrzeć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
podrzeć się: _: : perf: subj{np(str)} + {xp(dur)}
podrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podrzędny: : : : {comprepnp(w stosunku do)}
podrzędny: : : : {prepnp(dla,gen)}
podrzędny: : : : {prepnp(do,gen)}
podrzędny: : : : {prepnp(pod,inst)}
podrzędny: : : : {prepnp(wobec,gen)}
podrzędny: : : : {prepnp(względem,gen)}
podrzucać: _: : imperf: subj{E} + {np(str)} + {xp(adl)}
podrzucać: _: : imperf: subj{np(str)} + {cp(że)}
podrzucać: _: : imperf: subj{np(str)} + obj{np(inst)}
podrzucać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(adl)}
podrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podrzucić: _: : perf: subj{E} + {np(str)} + {xp(adl)}
podrzucić: _: : perf: subj{np(str)} + {cp(że)}
podrzucić: _: : perf: subj{np(str)} + obj{np(inst)}
podrzucić: _: : perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
podrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podskakiwać: _: : imperf: subj{np(str)} + {np(dat)}
podskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podskakiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podskakiwać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
podskoczyć: _: : perf: subj{np(str)} + {np(dat)}
podskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podskoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
podskoczyć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
podsłuchać: _: : perf: subj{np(str)} + {cp(że)}
podsłuchać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
podsłuchać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podsłuchiwać: _: : imperf: subj{np(str)} + {cp(że)}
podsłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
podsłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podstawiać się: _: : imperf: subj{np(str)} + {np(dat)}
podstawiać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
podstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
podstawić się: _: : perf: subj{np(str)} + {np(dat)}
podstawić się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
podstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podstawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podstawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
podstemplować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podstemplowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podstrajać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podstrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podstroić się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podstroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podstrzyc: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
podstrzyc: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podstrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
podstrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podstrzygać: _: : imperf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
podstrzygać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podstrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
podstrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podsumować: _: : perf: subj{np(str)} + {cp(int)}
podsumować: _: : perf: subj{np(str)} + {cp(że)}
podsumować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
podsumować: _: : perf: subj{np(str)} + {or}
podsumowywać: _: : imperf: subj{np(str)} + {cp(int)}
podsumowywać: _: : imperf: subj{np(str)} + {cp(że)}
podsumowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
podsumowywać: _: : imperf: subj{np(str)} + {or}
podsunąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
podsunąć się: _: : perf: subj{np(str)} + {xp(adl)}
podsunąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
podsunąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
podsunąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podsunąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
podsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podsuwać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podsuwać się: _: : imperf: subj{np(str)} + {xp(adl)}
podsuwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
podsuwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
podsuwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podsuwać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
podsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podsycać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
podsycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podsycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
podsycić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
podsycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podsycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
podszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
podszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
podszczuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
podszczuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podszczuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podszczuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
podszyć się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podszyć się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
podszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podszywać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podszywać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
podszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podświetlać się: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
podświetlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
podświetlić się: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
podświetlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
podtaczać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podtaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
podtapiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
podtapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podtapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podtoczyć się: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podtoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
podtopić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
podtopić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podtopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podtrzymać: _: : perf: subj{np(str)} + {cp(że)}
podtrzymać: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(na,loc,sg,'duch',natr)}
podtrzymać: _: : perf: subj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)} + {refl}
podtrzymać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
podtrzymać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
podtrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)}
podtrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
podtrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
podtrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podtrzymać: _: : perf: subj{np(str)} + {or}
podtrzymać: _: : perf: subj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)} + {refl}
podtrzymywać: _: : imperf: subj{np(str)} + {cp(że)}
podtrzymywać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(na,loc,sg,'duch',natr)}
podtrzymywać: _: : imperf: subj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)} + {refl}
podtrzymywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
podtrzymywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
podtrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)}
podtrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
podtrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
podtrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podtrzymywać: _: : imperf: subj{np(str)} + {or}
podtrzymywać: _: : imperf: subj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)} + {refl}
podtykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podusić się: _: : perf: subj{np(str)} + {np(inst)}
podusić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
podusić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
podusić się: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
podusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
podusić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)} + {xp(locat)}
podwajać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
podwajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podwajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
podważać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
podważać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podważyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
podważyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podwoić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
podwoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podwoić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
podwyższać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
podwyższać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podwyższyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
podwyższyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podyktować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
podyktować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
podyktować: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podyktować: _: : perf: subj{np(str)} + {np(dat)} + {or}
podyktować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
podyskutować: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); comprepnp(na temat); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
podyskutować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
podyskutować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
podyskutować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
podziać się: _: : perf: subj{np(str)} + {advp(misc)}
podziać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
podziać się: _: : perf: {xp(locat)} + {advp(misc)}
podziać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
podziałać: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
podziałać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
podzielić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {or}
podzielić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
podzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
podzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
podzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
podziękować: _: : perf: subj{np(str)} + {np(dat)} + {or}
podziękować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); cp(że); prepncp(za,acc,że)}
podziobać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
podziobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
podziobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
podziobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
podziobać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)}
podziobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podziobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
podziobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
podziobać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podziobać: _: : perf: subj{np(str)} + {xp(locat)}
podziurawić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
podziurawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podziwiać: _: : imperf: subj{np(str)} + {cp(jak)}
podziwiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
podziwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
podziwiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
podziwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podziwiać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
podzwaniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
podzwaniać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
podzwaniać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
podzwonić: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
podzwonić: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
podzwonić: _: : perf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
podzwonić: _: : perf: subj{np(str)} + {cp(int); cp(że); cp(żeby)} + {xp(abl)} + {xp(adl)}
podzwonić: _: : perf: subj{np(str)} + {np(dat)}
podzwonić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
podzwonić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
podzwonić: _: : perf: subj{np(str)} + {np(inst)}
podzwonić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
podzwonić: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)}
podzwonić: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)}
podzwonić: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(żeby)}
podzwonić: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
podzwonić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
podźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
podźwignąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
podźwignąć: _: : perf: subj{np(str)} + {xp(abl)} + {refl}
podżegać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
podżegać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
podżegać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podżegać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
pofałszować: _: : perf: subj{np(str)} + {cp(że)}
pofałszować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pofatygować się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
pofatygować się: _: : perf: subj{np(str)} + {cp(żeby)}
pofatygować się: _: : perf: subj{np(str)} + {np(inst)}
pofatygować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pofatygować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pofatygować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pofatygować się: _: : perf: subj{np(str)} + {xp(adl)}
pofatygować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pofikać: _: : perf: subj{np(str)} + {np(inst)}
pofikać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pofikać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
pofikać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pofolgować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pofolgować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pofruwać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pofruwać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
pogadać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
pogadać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pogadać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
pogadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pogadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pogadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
pogadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
poganiać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'kot',natr)}
poganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
poganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
poganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
poganiać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
pogardzać: _: : imperf: subj{np(str)} + {np(inst)}
pogardzić: _: : perf: subj{np(str)} + {np(inst)}
pogarszać się: _: : imperf: {np(dat)}
pogarszać się: _: : imperf: subj{np(str)} + {np(dat)}
pogarszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
pogarszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogawędzić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
pogawędzić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pogderać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
pogderać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
pogderać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pogderać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pogderać: _: : perf: subj{np(str)} + {np(dat)} + {or}
pogderać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pogderać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
pogiąć się: _: : perf: subj{np(str)} + {np(dat)}
pogiąć: _: : perf: {np(str)}
pogiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogładzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pogładzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogładzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pogłaskać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pogłaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogłaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pogłębiać się: _: : imperf: subj{np(str)} + {np(dat)}
pogłębiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
pogłębiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
pogłębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogłębić się: _: : perf: subj{np(str)} + {np(dat)}
pogłębić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pogłębić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
pogłębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogłowić się: _: : perf: subj{np(str)} + {cp(int)}
pogłowić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
pogłuchnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
pogmatwać się: _: : perf: subj{np(str)} + {np(dat)}
pogmatwać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pogmatwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pognać: _: : perf: {np(str)} + {prepnp(do,gen)}
pognać: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
pognać: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pognać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pognać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pognić: _: : perf: subj{np(str)} + {np(dat)}
pognieść się: _: : perf: subj{np(str)} + {np(dat)}
pognieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
pogniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pogniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
pogniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pogniewać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pogniewać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
pogniewać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pogniewać: _: : perf: subj{np(str)} + obj{np(str)}
pogodzić się: _: : perf: subj{np(str)} + {cp(że)}
pogodzić się: _: : perf: subj{np(str)} + {prepncp(z,inst,żeby2)}
pogodzić się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
pogodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
pogonić: _: : perf: {np(str)} + {xp(adl)}
pogonić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'kot',natr)}
pogonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
pogonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pogonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pogonić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
pogonić: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pogorszyć się: _: : perf: {np(dat)}
pogorszyć się: _: : perf: subj{np(str)} + {np(dat)}
pogorszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
pogorszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pograbić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {lexnp(dat,_,'siebie',natr)}
pograbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pograbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(pod,acc,_,'siebie',natr)}
pograbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pograbić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pograbić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pograbić: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
pogratulować: _: : perf: subj{np(str)} + {np(dat)} + {np(gen); cp(że); ncp(gen,że)}
pogrążać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
pogrążać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
pogrążać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
pogrążać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pogrążać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
pogrążać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pogrążać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
pogrążyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
pogrążyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
pogrążyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
pogrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pogrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
pogrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pogrążyć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
pogrozić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); cp(że); ncp(inst,że)} + {or}
pogrozić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pogrubić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogrupować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pogrupować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pogrupować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pogryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogryźć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pogryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pogryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
pogryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pogryźć: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
pogryźć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pogrzebać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pogrzebać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
pogrzebać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
pogrzebać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pogrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pogrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
pogrzebać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)} + {refl}
pogubić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pogubić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pogubić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pogwałcać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
pogwałcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogwałcić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
pogwałcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogwarzyć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
pogwarzyć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pogwarzyć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
poharatać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
poharatać: _: : perf: {np(dat)} + {np(str)}
poharatać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poharatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poharatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poharatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poharatać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
poholować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pohukiwać: _: : imperf: subj{np(str)} + {np(inst)}
pohukiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pohukiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
pohukiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
poinformować się: _: : perf: subj{np(str)} + {comprepnp(co do)} + {xp(locat)}
poinformować się: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {xp(locat)}
poinformować się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(locat)}
poinformować się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(locat)}
poinformować się: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
poinformować się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {xp(locat)}
poinformować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
poinformować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
poinformować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
poinformować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
poinformować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jakoby)}
poinformować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
poinformować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
poirytować się: _: : perf: subj{np(str)} + {cp(int)}
poirytować się: _: : perf: subj{np(str)} + {cp(że)}
poirytować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
poirytować się: _: : perf: subj{np(str)} + {or}
poirytować: _: : perf: subj{cp(gdy)} + {np(str)}
poirytować: _: : perf: subj{cp(int)} + {np(str)}
poirytować: _: : perf: subj{cp(jak)} + {np(str)}
poirytować: _: : perf: subj{cp(jeśli)} + {np(str)}
poirytować: _: : perf: subj{cp(kiedy)} + {np(str)}
poirytować: _: : perf: subj{cp(że)} + {np(str)}
poirytować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
poirytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pojawiać się: _: : imperf: subj{np(str)} + {xp(abl)}
pojawiać się: _: : imperf: subj{np(str)} + {xp(locat)}
pojawić się: _: : perf: subj{np(str)} + {xp(abl)}
pojawić się: _: : perf: subj{np(str)} + {xp(locat)}
pojąć: _: : perf: subj{np(str)} + {cp(int); cp(że)}
pojąć: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
pojąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
pojąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pojąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
pojąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(za,acc,_,'żona',natr)}
pojechać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
pojechać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pojechać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
pojedynkować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
pojeść: _: : perf: subj{np(str)} + {np(inst)} + {lexnp(dat,_,'siebie',natr)}
pojeść: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
pojeździć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pojeździć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pojeździć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pojeździć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pojmać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'niewola',atr)}
pojmać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pojmać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pojmać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pojmować: _: : imperf: subj{np(str)} + {cp(int); cp(że)}
pojmować: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
pojmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
pojmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pojmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
pojmować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,acc,_,'żona',natr)}
pokaleczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pokaleczyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pokaleczyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
pokaleczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pokaleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pokaleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pokaleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
pokasować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pokasować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(abl)}
pokasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
pokasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
pokaz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {preplexnp(w,loc,sg,'zakres',atr)}
pokaz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {preplexnp(z,gen,sg,'dziedzina',atr)}
pokaz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {preplexnp(z,gen,sg,'zakres',atr)}
pokaz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)}
pokaz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(z,gen)}
pokaz: : : : {np(gen)} + {adjp(agr)} + {possp} + {prepnp(dla,gen)}
pokaz: : : : {possp} + {cp(int)}
pokaz: : : : {possp} + {cp(że)}
pokazać się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
pokazać się: _: : perf: subj{np(str)} + {cp(że)}
pokazać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,pl,'oko',natr)}
pokazać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(od,gen,sg,'strona',ratr)}
pokazać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,sg,'strona',ratr)}
pokazać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pokazać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pokazać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pokazać: _: : perf: subj{np(str)} + controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {np(inst)}
pokazać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)}
pokazać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pokazać: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(po,loc,_,'siebie',natr)}
pokazywać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
pokazywać się: _: : imperf: subj{cp(że)}
pokazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,pl,'oko',natr)}
pokazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(od,gen,sg,'strona',ratr)}
pokazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,sg,'strona',ratr)}
pokazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
pokazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
pokazywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pokazywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pokazywać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(po,loc,_,'siebie',natr)}
pokazywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {np(inst)}
pokazywać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
pokąsać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pokąsać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pokierować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
pokierować: _: : perf: subj{np(str)} + obj{np(inst); ncp(inst,int)}
pokierować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
pokierować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pokiwać się: _: : perf: subj{np(str)}
pokiwać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pokiwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
pokiwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
pokiwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
poklaskać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poklaskać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
poklaskać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pokleić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
pokleić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
pokleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(z,inst)}
pokleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pokleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
pokleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pokleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pokleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poklepać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poklepać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poklepać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poklepywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poklepywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poklepywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poklęczeć: _: : perf: subj{np(str)} + {xp(locat)}
pokładać się: _: : imperf: subj{np(str)} + {xp(locat)}
pokładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
pokładać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pokłaść się: _: : perf: subj{np(str)} + {fixed('spać')}
pokłaść się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pokłaść się: _: : perf: subj{np(str)} + {xp(adl)}
pokłaść się: _: : perf: subj{np(str)} + {xp(locat)}
pokłaść: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('spać')}
pokłaść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pokłaść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
pokłócić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
pokłócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pokochać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pokochać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pokochać: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
pokochać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokochać: _: : perf: subj{np(str)} + {refl}
pokokietować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
pokokietować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
pokonać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokręcić się: _: : perf: {np(dat)} + {prepnp(od,gen)} + {prepnp(w,loc)}
pokręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pokręcić się: _: : perf: subj{np(str)} + {prepnp(koło,gen)}
pokręcić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pokręcić się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
pokręcić się: _: : perf: subj{np(str)} + {xp(locat)}
pokręcić: _: : perf: {np(str)}
pokręcić: _: : perf: subj{np(str)} + {np(inst)}
pokręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pokroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pokroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
pokruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pokruszyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
pokruszyć się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
pokruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pokruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pokryć się: _: : perf: subj{np(str)} + {np(inst)}
pokryć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pokryć się: _: : perf: subj{np(str)} + {xp(locat)}
pokryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokrywać się: _: : imperf: subj{np(str)} + {np(inst)}
pokrywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pokrywać się: _: : imperf: subj{np(str)} + {xp(locat)}
pokrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokrzepiać się: _: : imperf: subj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)}
pokrzepiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(na,loc,sg,'duch',natr)}
pokrzepiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
pokrzepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)}
pokrzepić się: _: : perf: subj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)}
pokrzepić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(na,loc,sg,'duch',natr)}
pokrzepić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pokrzepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,loc,sg,'duch',natr)}
pokrzyczeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
pokrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
pokrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
pokrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pokrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
pokrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
pokrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokrzykiwać: _: : imperf: subj{np(str)} + {np(str); cp(że); cp(żeby)} + {prepnp(do,gen)}
pokrzykiwać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(za,inst)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {nonch}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
pokrzykiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
pokrzywdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokrzywić się: _: : perf: subj{np(str)} + {np(dat)}
pokrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pokrzyżować się: _: : perf: subj{np(str)} + {np(dat)}
pokrzyżować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pokrzyżować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pokształcić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pokształcić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pokształcić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pokształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pokuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
pokuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pokusić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
pokusić się: _: : perf: subj{np(str)} + {cp(żeby)}
pokusić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pokusić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
pokusić: _: : perf: subj,controllee{infp(_)} + controller{np(str)}
pokusić: _: : perf: subj{cp(żeby)} + {np(str)}
pokusić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pokusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pokutować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokutować: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
pokutować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
pokutować: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)}
pokutować: _: : imperf: subj{np(str)} + {xp(locat)}
pokwitować: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
pokwitować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
polać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
polać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
polać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polakierować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
polakierować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polakierować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
polamentować: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
polamentować: _: : perf: subj{np(str)} + {cp(int)}
polamentować: _: : perf: subj{np(str)} + {cp(że)}
polamentować: _: : perf: subj{np(str)} + {or}
polamentować: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
polatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
polatywać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
polatywać: _: : imperf: subj{np(str)} + {xp(locat)}
pole: : : : {np(gen)} + {possp}
pole: : : : {possp} + {prepnp(pod,acc)}
pole: : : : {prepnp(dla,gen); prepnp(do,gen); prepncp(do,gen,żeby)}
polec: _: : perf: subj{np(str)} + {prepnp(od,gen)}
polec: _: : perf: subj{np(str)} + {prepnp(za,acc)}
polecać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(na,acc,sg,'przyszłość',natr)}
polecać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
polecać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
polecać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
polecać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
polecać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
polecać: _: : imperf: subj{np(str)} + obj,controllee{np(str); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)}
polecać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
polecać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
polecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
polecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
polecenie: : : : {np(gen)} + {possp} + {prepnp(dla,gen)}
polecenie: : : : {possp} + {comprepnp(w stosunku do)} + {cp(żeby)}
polecenie: : : : {possp} + {prepnp(co do,gen)} + {prepnp(dla,gen)}
polecenie: : : : {possp} + {prepnp(dla,gen)} + {comprepnp(na temat)}
polecenie: : : : {possp} + {prepnp(dla,gen)} + {cp(że)}
polecenie: : : : {possp} + {prepnp(dla,gen)} + {cp(żeby)}
polecenie: : : : {possp} + {prepnp(dla,gen)} + {or}
polecenie: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)}
polecenie: : : : {possp} + {prepnp(dla,gen)} + {prepnp(na,acc)}
polecenie: : : : {possp} + {prepnp(dla,gen)} + {prepnp(o,acc)}
polecenie: : : : {possp} + {prepnp(wobec,gen)} + {cp(żeby)}
polecenie: : : : {possp} + {prepnp(względem,gen)} + {cp(żeby)}
polecenie: : : : {prepnp(dla,gen)} + {prepnp(od,gen)} + {cp(żeby)}
polecić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(na,acc,sg,'przyszłość',natr)}
polecić: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
polecić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
polecić: _: : perf: subj{np(str)} + {np(dat)} + {or}
polecić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
polecić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
polecić: _: : perf: subj{np(str)} + obj,controllee{np(str); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)}
polecić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
polecić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
polecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
polecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
polecieć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
polecieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
polecieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
polecieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {or}
polecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
polecieć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
polecieć: _: : perf: subj{np(str)} + {prepnp(po,acc)}
polecieć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
polegać: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
polemiczny: : : : {comprepnp(w stosunku do)}
polemiczny: : : : {prepnp(do,gen)}
polemiczny: : : : {prepnp(wobec,gen)}
polemiczny: : : : {prepnp(względem,gen)}
polemiczny: : : : {prepnp(z,inst)}
polemizować: _: : imperf: subj{np(str)} + {cp(int)}
polemizować: _: : imperf: subj{np(str)} + {cp(że)}
polemizować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
polemizować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
polemizować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
polemizować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
polemizować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
polemizować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
polepszać się: _: : imperf: {np(dat)}
polepszać się: _: : imperf: subj{np(str)} + {np(dat)}
polepszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
polepszyć się: _: : perf: {np(dat)}
polepszyć się: _: : perf: subj{np(str)} + {np(dat)}
polepszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
polerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polewać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
polewać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
polewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polewać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
poleżeć: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
policzyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
policzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
policzyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
policzyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)} + {np(dat)}
policzyć: _: : perf: subj{np(str)} + obj{cp(int)}
policzyć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
policzyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
policzyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poliniować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poliniować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
politykować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
politykować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
politykować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
politykować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
polizać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
polizać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
polizać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
polizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
polizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
polizać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
polokować się: _: : perf: subj{np(str)} + {xp(locat)}
polokować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
polokować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
polokować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
polować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
polubić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
polubić: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
polubić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
polutować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
polutować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
połajać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
połajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
połamać się: _: : perf: subj{np(str)} + {np(dat)}
połamać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
połamać: _: : perf: {np(str)} + {prepnp(w,loc)}
połamać: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
połamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
połamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
połamać: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
połamać: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'ząb',atr)}
połapać się: _: : perf: subj{np(str)} + {cp(int)}
połapać się: _: : perf: subj{np(str)} + {cp(że)}
połapać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
połapać się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
połapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
połapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
połatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
połazikować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
połazikować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
połączyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
połączyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
połączyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
połączyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(z,inst)}
połączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
połączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
połączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
połechtać: _: : perf: {np(str)} + {xp(locat)}
połechtać: _: : perf: subj{cp(gdy)} + {np(str)}
połechtać: _: : perf: subj{cp(int)} + {np(str)}
połechtać: _: : perf: subj{cp(jak)} + {np(str)}
połechtać: _: : perf: subj{cp(kiedy)} + {np(str)}
połechtać: _: : perf: subj{cp(że)} + {np(str)}
połechtać: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
połechtać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
połechtać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
połechtać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
połechtać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
połechtać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
połechtać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
połechtać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
połknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
położyć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
położyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
położyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
położyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
położyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
położyć: _: : perf: subj,controller{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + controllee{prepnp(jako,str)}
położyć: _: : perf: subj{np(str)} + {lexnp(str,pl,'ucho',natr)} + {preplexnp(po,loc,_,'siebie',natr)}
położyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{fixed('spać')}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {comprepnp(w kwestii)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {preplexnp(na,loc,sg,'pole',atr)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(dla,gen)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(przy,loc)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(w,acc)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'zasługi',atr)} + {prepnp(w,loc)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'koniec',natr)} + {np(dat)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'kres',natr)} + {np(dat)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'krzyżyk',natr)} + {prepnp(na,loc)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'łapa',natr)} + {prepnp(na,loc)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'ręka',natr)} + {prepnp(na,loc)}
położyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'tama',natr)} + {np(dat)}
położyć: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(inst,sg,'trup',natr)}
położyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
położyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
położyć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'łopatka',atr)}
położyć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'karb',ratr)}
położyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
połykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
połyskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pomachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
pomachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
pomachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pomachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pomachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pomachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
pomachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
pomachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
pomachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
pomagać: _: : imperf: subj{cp(że)} + {np(dat)}
pomagać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
pomagać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
pomagać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pomagać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pomagać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
pomagać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
pomarszczyć się: _: : perf: subj{np(str)} + {np(dat)}
pomarszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomarzyć: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
pomarzyć: _: : perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
pomarzyć: _: : perf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {lexnp(dat,_,'siebie',natr)}
pomaszerować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pomawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
pomawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
pomazać się: _: : perf: subj{np(str)} + {np(inst)}
pomazać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pomazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pomdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pomdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pomiaukiwać: _: : imperf: subj{np(str)}
pomieszać się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
pomieszać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pomieszać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
pomieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pomieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pomieścić się: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
pomieścić się: _: : perf: subj{cp(żeby2)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
pomieścić się: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
pomieścić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
pomieścić się: _: : perf: subj{np(str)} + {xp(locat)}
pomieścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pomijać: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {lexnp(inst,sg,'milczenie',atr)}
pomijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
pomijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pominąć: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {lexnp(inst,sg,'milczenie',atr)}
pominąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
pominąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pomizernieć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
pomknąć: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pomnażać się: _: : imperf: subj{np(str)} + {np(dat)}
pomnażać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
pomnażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pomnażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
pomniejszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pomniejszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pomniejszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pomniejszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pomnożyć się: _: : perf: subj{np(str)} + {np(dat)}
pomnożyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
pomnożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pomnożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
pomnożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
pomny: : : : {cp(int)}
pomny: : : : {cp(że)}
pomny: : : : {cp(żeby)}
pomny: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
pomny: : : : {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pomodlić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {or}
pomodlić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {cp(żeby)}
pomodlić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,inst)} + {cp(żeby)}
pomóc: _: : perf: subj{cp(że)} + {np(dat)}
pomóc: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
pomóc: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
pomóc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pomóc: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pomóc: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
pomóc: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pomówić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
pomówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
pomówić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
pomówić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pomówić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
pomówić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pomówić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
pomówić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
pomstować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
pomstować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pomstować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
pomstować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pomstować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że)}
pomścić się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)} + {prepnp(na,loc)}
pomścić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pomścić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pomścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pomścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pomurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pomurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pomuzykować: _: : perf: subj{np(str)}
pomyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomyć: _: : perf: subj{np(str)} + {refl}
pomykać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pomylić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pomylić się: _: : perf: subj{np(str)} + {prepnp(co do,gen)}
pomylić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pomylić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
pomylić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pomyłka: : : : {possp} + {comprepnp(na temat)}
pomyłka: : : : {possp} + {comprepnp(w kwestii)}
pomyłka: : : : {possp} + {comprepnp(w sprawie)}
pomyłka: : : : {possp} + {comprepnp(w stosunku do)}
pomyłka: : : : {possp} + {cp(że)}
pomyłka: : : : {possp} + {preplexnp(w,loc,sg,'zakres',atr)}
pomyłka: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
pomyłka: : : : {possp} + {prepnp(o,acc)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
pomyłka: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,że)}
pomyłka: : : : {possp} + {prepnp(wobec,gen)}
pomyłka: : : : {possp} + {prepnp(względem,gen)}
pomyłka: : : : {possp} + {prepnp(z,inst)}
pomysł: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)} + {possp}
pomysł: : : : {possp} + {comprepnp(na temat); preplexnp(z,gen,sg,'zakres',atr)}
pomysł: : : : {possp} + {comprepnp(w kwestii)}
pomysł: : : : {possp} + {comprepnp(w sprawie)}
pomysł: : : : {possp} + {cp(int)}
pomysł: : : : {possp} + {cp(jakoby)}
pomysł: : : : {possp} + {cp(że)}
pomysł: : : : {possp} + {or}
pomysł: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
pomysł: : : : {possp} + {prepnp(na,acc); prepnp(o,loc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pomyśleć: _: : perf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{prepnp(jako,str)}
pomyśleć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
pomyśleć: _: : perf: subj{np(str)} + obj,controller{prepnp(o,loc)} + controllee{xp(mod)}
pomyśleć: _: : perf: subj{np(str)} + {or}
pomyśleć: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
pomyśleć: _: : perf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pomyśleć: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
pomyśleć: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {nonch}
ponadawać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
ponadawać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
ponadawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
ponadawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ponaddzierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
ponaddzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
ponadgryzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ponadrywać się: _: : perf: subj{np(str)} + {np(dat)}
ponadrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ponaglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
ponaglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
ponaglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ponaglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
ponaglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
ponaglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ponakręcać: _: : perf: subj{np(str)} + {cp(że)} + {refl}
ponakręcać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ponakręcać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
ponakręcać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
ponakręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ponakręcać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ponakręcać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ponakręcać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
ponakrywać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ponakrywać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(gdy)} + {xp(locat)}
ponakrywać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {xp(locat)}
ponakrywać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(kiedy)} + {xp(locat)}
ponakrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ponakrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ponakrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
ponalewać się: _: : perf: subj{np(part)} + {np(dat)} + {xp(adl)} + {xp(perl)}
ponalewać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
ponaprawiać się: _: : perf: subj{np(str)}
ponaprawiać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
ponapychać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ponapychać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
ponapychać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ponarażać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ponarażać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)} + {refl}
ponarażać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)}
ponarażać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
ponarażać: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {refl}
ponarzucać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
ponarzucać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
ponarzucać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
ponarzucać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
ponarzucać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
ponarzucać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
ponasadzać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
ponasadzać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
ponasadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
ponastawiać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
ponastawiać się: _: : perf: subj{np(str)} + {cp(że)}
ponastawiać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
ponastawiać: _: : perf: subj{np(str)} + controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
ponastawiać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
ponastawiać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(locat)}
ponastawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ponastawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
ponastawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
ponauczać się: _: : perf: subj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {prepnp(od,gen); prepnp(z,gen)}
ponauczać się: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
ponauczać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
ponauczać: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
ponauczać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {np(inst)}
ponauczać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
ponauczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
ponawiać się: _: : imperf: subj{np(str)}
ponawiać: _: : imperf: subj{np(str)} + obj{np(str)}
poniechać: _: : perf: subj{np(str)} + obj{np(gen)}
ponieść: _: : perf: {np(str)} + {xp(adl)}
ponieść: _: : perf: subj{np(str)} + {np(str)}
ponieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
poniewierać się: _: : imperf: subj{np(str)} + {xp(locat)}
poniewierać: _: : imperf: subj{np(str)} + obj{np(inst)}
poniewierać: _: : imperf: subj{np(str)} + obj{np(str)}
poniżać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
poniżać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
poniżać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
poniżać się: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
poniżać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
poniżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
poniżyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
poniżyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
poniżyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
poniżyć się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
poniżyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
poniżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ponosić: _: : perf: subj{np(str)} + obj{np(str)}
ponosić: _: : imperf: {np(str)}
ponosić: _: : imperf: subj{np(str)} + {np(str)}
ponosić: _: : imperf: subj{np(str)} + obj{np(str)}
ponowić się: _: : perf: subj{np(str)}
ponowić: _: : perf: subj{np(str)} + obj{np(str)}
ponudzić się: _: : perf: subj{np(str)}
ponudzić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
ponudzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
ponudzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
ponudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ponudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
ponumerować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ponumerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ponury: : pred: : {cp(gdy)}
ponury: : pred: : {cp(jeśli)}
ponury: : pred: : {cp(że)}
ponury: : pred: : {cp(żeby)}
poobalać się: _: : perf: subj{np(str)} + {xp(adl)}
poobalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
poobciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
poobijać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
poobijać się: _: : perf: subj{np(str)} + {xp(locat)}
poobijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poobijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poobijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pooblepiać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pooblepiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
pooblepiać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pooblepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobłupywać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poobłupywać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
poobłupywać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poobłupywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poobłupywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
poobłupywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poobracać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
poobracać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
poobracać się: _: : perf: subj{np(str)} + {prepadjp(na,acc)}
poobracać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poobracać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poobracać się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
poobracać się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
poobracać się: _: : perf: subj{np(str)} + {xp(locat)}
poobracać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
poobracać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
poobracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poobracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poobracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
poobrastać: _: : perf: subj{np(str)} + {np(inst)}
poobrastać: _: : perf: subj{np(str)} + obj{np(str)}
poobrastać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
poobrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poobrzynać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
poobrzynać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poobrzynać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
poobrzynać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poobsiadać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
poobszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
poobszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poocierać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
poocierać się: _: : perf: subj{np(str)} + {xp(locat)}
poocierać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
poocierać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
poocierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poocierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
poocierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pooczyszczać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pooczyszczać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
pooczyszczać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
pooczyszczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
pooczyszczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poodbierać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
poodbierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poodbierać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
poodchodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poodchodzić: _: : perf: subj{np(str)} + {np(str)}
poodchodzić: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {comprepnp(na rzecz)}
poodchodzić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
poodginać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poodginać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
poodginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
poodginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
poodgryzać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
poodgryzać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
poodgryzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
poodkładać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poodkładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
poodkładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
poodkładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poodkładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
poodkładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
poodkrywać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
poodkrywać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
poodkrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
poodkrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poodkrywać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
poodkrywać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
poodnawiać się: _: : perf: subj{np(str)} + {np(dat)}
poodnawiać się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
poodnawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poodnosić się: _: : perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
poodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
poodrzucać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(od,gen)}
poodrzucać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(od,gen)}
poodrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poodrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poodrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
poodsłaniać się: _: : perf: subj{np(str)} + {np(dat)}
poodsłaniać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
poodsłaniać się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
poodsłaniać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poodsłaniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
poodsłaniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
poodsuwać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
poodsuwać się: _: : perf: subj{np(str)} + {xp(adl)}
poodsuwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poodsuwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
poodwiedzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poodwozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pooglądać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pooglądać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
pooglądać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jak)}
pooglądać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
pooglądać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pooglądać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pookładać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pookładać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pookładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pookładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pookładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pookładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(z,gen)}
pookradać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pookradać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poopatrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poopatrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poopierać się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
poopierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poopierać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
poopierać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
poopierać się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
poopierać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
poopierać się: _: : perf: subj{np(str)} + {xp(locat)}
poopierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
poopierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
poopisywać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
poopisywać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
poopisywać: _: : perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)}
poostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
poostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
poostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pootrząsać się: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)}
pootrząsać się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
pootrząsać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pootulać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pootulać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pootulać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pootulać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pooznaczać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
pooznaczać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pooznaczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pooznaczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
popaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
popaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popadać: _: : perf: subj{E}
popadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
popadać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
popadać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
popadać: _: : perf: subj{np(str)} + {xp(adl)}
popadać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {preplexnp(w,acc,sg,'niełaska',natr)}
popadać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
popaprać się: _: : perf: {np(dat)} + {prepnp(w,loc)}
popaprać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
popaprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poparcie: : : : {np(gen)} + {possp}
poparcie: : : : {possp} + {prepnp(co do,gen)} + {prepnp(dla,gen)}
poparcie: : : : {possp} + {prepnp(dla,gen)} + {comprepnp(na rzecz)}
poparcie: : : : {possp} + {prepnp(dla,gen)} + {comprepnp(w kwestii)}
poparcie: : : : {possp} + {prepnp(dla,gen)} + {comprepnp(w sprawie)}
poparcie: : : : {possp} + {prepnp(dla,gen)} + {prepnp(w,loc)}
poparcie: : : : {possp} + {prepnp(dla,gen)} + {xp(locat)}
poparcie: : : : {possp} + {prepnp(wobec,gen)}
poparcie: : : : {possp} + {prepnp(względem,gen)}
popaść się: _: : perf: subj{np(str)} + {np(inst)}
popaść się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
popaść: _: : perf: subj{np(str)} + {np(dat)}
popaść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popaść: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {preplexnp(w,acc,sg,'niełaska',natr)}
popaść: _: : perf: subj{np(str)} + {prepnp(w,acc)}
popatrzeć się: _: : perf: subj{np(str)} + {cp(int)}
popatrzeć się: _: : perf: subj{np(str)} + {cp(jak)}
popatrzeć się: _: : perf: subj{np(str)} + {cp(że)}
popatrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
popatrzeć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
popatrzeć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
popatrzeć: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
popatrzeć: _: : perf: subj{np(str)} + {cp(jak)}
popatrzeć: _: : perf: subj{np(str)} + {cp(że)}
popatrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
popatrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepnp(po,loc); prepnp(w,acc); cp(int); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że); xp(locat)}
popatrzeć: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
popatrzyć się: _: : perf: subj{np(str)} + {cp(int)}
popatrzyć się: _: : perf: subj{np(str)} + {cp(jak)}
popatrzyć się: _: : perf: subj{np(str)} + {cp(że)}
popatrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
popatrzyć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
popatrzyć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
popatrzyć: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
popatrzyć: _: : perf: subj{np(str)} + {cp(jak)}
popatrzyć: _: : perf: subj{np(str)} + {cp(że)}
popatrzyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
popatrzyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzyć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepnp(po,loc); prepnp(w,acc); cp(int); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że); xp(locat)}
popatrzyć: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
popchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
popchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
popełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popełnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popełznąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
popędzać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'kot',natr)}
popędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
popędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
popędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
popędzić: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
popędzić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'kot',natr)}
popędzić: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
popędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
popędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
popędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
popędzić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
popędzić: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
popędzić: _: : perf: subj{np(str)} + {prepnp(za,inst)}
popękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
popękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
popętać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
popętać się: _: : perf: subj{np(str)} + {xp(perl)}
popętać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
popętać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popętać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popić się: _: : perf: subj{np(str)} + {np(inst)}
popić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
popić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popiec się: _: : perf: subj{np(str)} + {np(inst)}
popiec się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
popiec się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
popiec: _: : perf: {np(str)} + {xp(locat)}
popiec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
popiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
popiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
popieprzyć się: _: : perf: {np(dat)} + {xp(locat)}
popieprzyć się: _: : perf: subj{cp(int)} + {np(dat)}
popieprzyć się: _: : perf: subj{cp(że)} + {np(dat)}
popieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
popieprzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
popieprzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
popieprzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
popieprzyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
popieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
popieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
popieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popieprzyć: _: : perf: subj{np(str)} + {refl}
popierać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst)}
popierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
popijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
popisać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
popisać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {or}
popisać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
popisać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
popisać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
popisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popisać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
popisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
popisać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {xp(locat)}
popisywać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
popisywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {or}
popisywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
popisywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
poplamić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
poplamić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poplamić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poplątać się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
poplątać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
poplątać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poplątać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
poplątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poplątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
popłacać: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
popłacać: _: : imperf: subj{np(str)} + {np(dat)}
popłacić: _: : perf: subj{np(str)} + {np(dat)}
popłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popłakać się: _: : perf: subj{np(str)} + {cp(że)}
popłakać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popłakać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
popłakać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
popłakać: _: : perf: subj{np(str)} + {cp(że)}
popłakać: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
popłakać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
popłoszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
popłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
popłynąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
popłynąć: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {prepnp(za,inst)}
popłynąć: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
popłynąć: _: : perf: subj{np(str)} + {xp(locat)}
popływać: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(dur)} + {xp(perl)}
popływać: _: : perf: subj{np(str)} + {xp(locat)}
popodkreślać: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
popodkreślać: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
popodkreślać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
popodlewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popodlewać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
popodnosić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
popodnosić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
popodnosić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
popodnosić się: _: : perf: subj{np(str)} + {xp(abl)}
popodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'duch',natr)}
popodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
popodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
popodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
popodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
popodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
popodnosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
popodpierać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
popodpierać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
popodpierać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
popodpierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popodpierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
popodpierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
popodpierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
popowstawać: _: : perf: subj{np(str)} + {np(dat)}
popowstawać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
popowstawać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
popowstawać: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
popowstawać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
popowstawać: _: : perf: subj{np(str)} + {xp(abl)}
popracować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(dur)}
popracować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {comprepnp(na rzecz)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że); prepncp(nad,inst,żeby)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
popracować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)} + {xp(locat)}
poprawiać się: _: : imperf: {np(dat)} + {prepnp(w,loc)}
poprawiać się: _: : imperf: subj{np(str)} + {np(dat)}
poprawiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
poprawiać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
poprawiać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
poprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprawić się: _: : perf: {np(dat)} + {prepnp(w,loc)}
poprawić się: _: : perf: subj{np(str)} + {np(dat)}
poprawić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poprawić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poprawić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
poprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprosić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
poprosić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
poprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(o,acc,żeby)}
poprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
poprosić: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poprowadzić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
poprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
poprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
poprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
popróchnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popróchnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poprzebierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poprzebierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
poprzebierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
poprzebierać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
poprzebierać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)} + {refl}
poprzebierać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poprzebierać: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
poprzeciągać się: _: : perf: subj{np(str)} + {xp(dur)}
poprzeciągać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poprzeciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
poprzeciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
poprzeciągać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
poprzeciągać: _: : perf: subj{np(str)} + {xp(perl)}
poprzecinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
poprzeć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst)}
poprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poprzedzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
poprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzedzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
poprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzekształcać się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
poprzekształcać się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
poprzekształcać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzekształcać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
poprzekształcać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
poprzekształcać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
poprzekształcać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzekształcać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
poprzenosić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poprzenosić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
poprzenosić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
poprzenosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poprzenosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzenosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
poprzenosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poprzenosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
poprzerabiać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
poprzerabiać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
poprzerabiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzerabiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
poprzerabiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
poprzerastać: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
poprzerastać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
poprzerastać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
poprzerzucać się: _: : perf: subj{np(str)} + {np(inst)}
poprzerzucać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzerzucać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
poprzerzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(nad,inst)}
poprzerzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
poprzerzucać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzerzucać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
poprzesadzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
poprzesadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
poprzesadzać: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
poprzesadzać: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
poprzesłaniać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
poprzestać: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
poprzestawać: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
poprzestawiać się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
poprzestawiać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
poprzestawiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzestawiać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
poprzestawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
poprzestawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
poprzestawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poprzestawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
poprzeszywać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poprzeszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzewiązywać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poprzewiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzewiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
poprzewiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poprzewiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
poprzewiercać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
poprzewiercać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poprzewiercać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzewiercać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poprzybierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzybierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poprzybierać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poprzybierać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
poprzychodzić: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
poprzychodzić: _: : perf: subj,controller{infp(_)} + controllee{np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
poprzychodzić: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
poprzychodzić: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
poprzychodzić: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
poprzychodzić: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
poprzychodzić: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
poprzychodzić: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
poprzychodzić: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
poprzychodzić: _: : perf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
poprzychodzić: _: : perf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
poprzychodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
poprzychodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
poprzychodzić: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'świat',natr)}
poprzychodzić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poprzychodzić: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
poprzychodzić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
poprzychodzić: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
poprzychodzić: _: : perf: subj{np(str)} + {xp(adl)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
poprzyciągać: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen)}
poprzyciągać: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {xp(adl)}
poprzyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
poprzyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {xp(abl)} + {xp(adl)}
poprzyjmować się: _: : perf: subj{np(str)}
poprzyjmować: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,sg,'wiara',natr)}
poprzyjmować: _: : perf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{prepadjp(za,acc)}
poprzyjmować: _: : perf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{prepnp(za,acc)}
poprzyjmować: _: : perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
poprzyjmować: _: : perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)}
poprzyjmować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
poprzyjmować: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
poprzyjmować: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(za,acc)}
poprzyjmować: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(za,inst)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {preplexnp(do,gen,sg,'wiadomość',atr)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {preplexnp(na,acc,sg,'wiara',natr)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(za,inst)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,_,'dach',batr)} + {fixed('z otwartymi ramionami')}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi ramionami')}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi rękami')}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poprzyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
poprzykładać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
poprzykładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
poprzykładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
poprzykładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzykładać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poprzykręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(na,acc)}
poprzykrywać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poprzykrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzynosić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
poprzysiadać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poprzysiadać: _: : perf: subj{np(str)} + {lexnp(gen,_,'fałd',natr)}
poprzysiadać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poprzysiadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poprzysiadać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poprzysiadać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poprzysiadać: _: : perf: subj{np(str)} + {xp(adl)}
poprzysłaniać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
poprzysłaniać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poprzysłaniać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
poprzystrajać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poprzystrajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzystrajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poprzystrajać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
poprzywiązywać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
poprzywiązywać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {refl}
poprzywiązywać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
poprzywiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)}
poprzywozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
popsuć się: _: : perf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
popsuć się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
popsuć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popsuć: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
popsuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
popularyzować się: _: : imperf: subj{np(str)} + {xp(locat)}
popularyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
popychać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
popychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
popychać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,że)}
popychać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pora: _: : imperf: controller{np(dat)} + controllee{infp(_)}
pora: _: : imperf: {cp(żeby)}
pora: _: : imperf: {prepnp(na,acc); prepncp(na,acc,żeby)}
pora: _: : imperf: {xp(adl)}
porabiać: _: : imperf: subj{np(str)} + {nonch} + {xp(dur)}
porabiać: _: : imperf: subj{np(str)} + {nonch} + {xp(locat)}
porać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
poradzić się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(na temat)}
poradzić się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(w kwestii)}
poradzić się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(w sprawie)}
poradzić się: _: : perf: subj{np(str)} + {np(gen)} + {cp(int)}
poradzić się: _: : perf: subj{np(str)} + {np(gen)} + {preplexnp(w,loc,sg,'temat',atr)}
poradzić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
poradzić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
poradzić: _: : perf: subj{np(str)} + {np(dat)} + {or}
poradzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {nonch}
poradzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poradzić: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że); prepncp(z,inst,żeby)} + {lexnp(dat,_,'siebie',natr)}
porastać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
porastać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porastać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
porazić się: _: : perf: subj{np(str)} + {np(inst)}
porazić: _: : perf: {np(dat)} + {np(inst)} + {np(str)}
porazić: _: : perf: subj{cp(gdy)} + {np(str)}
porazić: _: : perf: subj{cp(int)} + {np(str)}
porazić: _: : perf: subj{cp(jak)} + {np(str)}
porazić: _: : perf: subj{cp(jeśli)} + {np(str)}
porazić: _: : perf: subj{cp(kiedy)} + {np(str)}
porazić: _: : perf: subj{cp(że)} + {np(str)}
porazić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
porazić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
porazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
porazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
porażać się: _: : imperf: subj{np(str)} + {np(inst)}
porażać: _: : imperf: subj{cp(gdy)} + {np(str)}
porażać: _: : imperf: subj{cp(int)} + {np(str)}
porażać: _: : imperf: subj{cp(jak)} + {np(str)}
porażać: _: : imperf: subj{cp(jeśli)} + {np(str)}
porażać: _: : imperf: subj{cp(kiedy)} + {np(str)}
porażać: _: : imperf: subj{cp(że)} + {np(str)}
porażać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
porażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
poreperować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {cp(że)}
poręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
poręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {cp(że)}
poręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
poręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porobić się: _: : perf: {np(dat)} + {advp(misc)}
porobić się: _: : perf: {prepnp(z,inst)} + {advp(misc)}
porobić się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
porobić się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
porobić się: _: : perf: subj{nonch} + {prepnp(z,inst)}
porobić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porobić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
porobić się: _: : perf: {xp(locat)} + {advp(misc)}
porobić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
porobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
porobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
porobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
porobić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
poromansować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poronić: _: : perf: subj{np(str)} + obj{np(str)}
porosnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porosnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porosnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
porozbiegać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
porozbiegać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
porozbiegać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porozbiegać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
porozbijać się: _: : perf: subj{np(str)} + {np(inst)}
porozbijać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc)}
porozbijać się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
porozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
porozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
porozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
porozcinać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
porozcinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
porozcinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
porozcinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
porozganiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
porozganiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
porozjeżdżać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
porozjeżdżać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(locat)}
porozjeżdżać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
porozjeżdżać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porozkradać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
porozmawiać: _: : perf: subj{np(str)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
porozmawiać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
porozmawiać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
porozmawiać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(o,loc,żeby)}
porozpoczynać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
porozpoczynać się: _: : perf: subj{np(str)} + {np(inst)}
porozpoczynać się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
porozpoczynać się: _: : perf: subj{np(str)} + {xp(locat)}
porozpoczynać się: _: : perf: subj{np(str)} + {xp(temp)}
porozpoczynać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
porozpoczynać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
porozpoczynać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
porozpuszczać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
porozpuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
porozpuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
porozpuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
porozpuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
porozrastać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porozrastać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
porozrastać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
porozrastać się: _: : perf: subj{np(str)} + {xp(adl)}
porozrywać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
porozrywać: _: : perf: {np(dat)} + {np(str)} + {prepnp(na,acc)}
porozrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
porozsyłać się: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
porozsyłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porozsyłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
porozsyłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
porozsyłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
porozsyłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
porozsyłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
poroztrącać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
poroztrząsać: _: : perf: subj{np(str)} + obj{cp(int)}
poroztrząsać: _: : perf: subj{np(str)} + obj{cp(że)}
poroztrząsać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
porozumieć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
porozumieć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
porozumieć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
porozumiewać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
porozumiewać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
porozumiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
porozwieszać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porównać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
porównać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
porównać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
porównać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
porównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
porównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
porównywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
porównywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {refl}
portretować się: _: : imperf: subj{np(str)}
portretować: _: : imperf: subj{np(str)} + obj{np(str)}
portretować: _: : imperf: subj{np(str)} + {refl}
poruszać się: _: : perf: subj{np(str)}
poruszać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,loc)}
poruszać się: _: : imperf: subj{np(str)} + {np(inst)}
poruszać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
poruszać się: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
poruszać: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
poruszać: _: : imperf: subj{cp(że)} + {np(str)}
poruszać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
poruszać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
poruszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
poruszyć się: _: : perf: subj{np(str)}
poruszyć: _: : perf: subj{cp(że)} + {np(str)}
poruszyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
poruszyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
poruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
porwać się: _: : perf: subj{np(str)} + {np(dat)}
porwać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
porwać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
porwać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
porwać się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
porwać się: _: : perf: subj{np(str)} + {xp(abl)}
porwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
porwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
porwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
porwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
porwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
porykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
porykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
porykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
porykiwać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
porykiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
porywać się: _: : imperf: subj{np(str)} + {np(dat)}
porywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
porywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
porywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
porywać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
porywać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
porywać się: _: : imperf: subj{np(str)} + {xp(abl)}
porywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
porywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
porywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
porywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
porywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
porywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
porywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
porządkować się: _: : imperf: subj{np(str)}
porządkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porzeźbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
porzucać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
porzucać: _: : perf: subj{np(str)} + {np(str)} + {xp(adl)}
porzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
porzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
porzucić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
posadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
posadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
posapywać: _: : imperf: subj{np(str)} + {np(inst)}
posapywać: _: : imperf: subj{np(str)} + {or}
posapywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
posapywać: _: : imperf: subj{np(str)} + {xp(adl)}
posądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
posądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby2)}
posądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby2)}
posądzać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {refl}
posądzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
posądzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby2)}
posądzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby2)}
posądzić: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {refl}
poschnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poschnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poseł: : : : {possp} + {prepnp(do,gen); prepnp(na,acc)} + {xp(abl)}
poseł: : : : {prepnp(do,gen); prepnp(na,acc)} + {xp(abl)} + {preplexnp(z,gen,sg,'ramię',atr)}
poseł: : : : {prepnp(do,gen)} + {prepnp(od,gen)}
posępnieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
posiać się: _: : perf: subj{np(str)} + {xp(locat)}
posiać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
posiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
posiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
posiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
posiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
posiadać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
posiadać: _: : perf: subj{np(str)} + {xp(locat)}
posiadać: _: : imperf: subj{np(str)} + {np(str)}
posiadać: _: : imperf: subj{np(str)} + obj{np(str)}
posiąść się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
posiąść: _: : perf: subj{np(str)} + {np(str)}
posiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(dur)} + {xp(locat)}
posiedzieć: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {xp(dur)}
posiedzieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(dur)}
posiedzieć: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
posiedzieć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(dur)}
posiedzieć: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {xp(dur)}
posilać się: _: : imperf: subj{np(str)} + {np(inst)}
posilać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
posilić się: _: : perf: subj{np(str)} + {np(inst)}
posilić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
posiłkować się: _: : imperf: subj{np(str)} + {np(inst)}
posiłkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
posiodłać: _: : perf: subj{np(str)} + obj{np(str)}
posiwieć: _: : perf: subj{np(str)} + {np(dat)}
posiwieć: _: : perf: subj{np(str)} + {xp(locat)}
posiwieć: _: : perf: {xp(locat)}
poskarżyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int); cp(że)}
poskarżyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
poskarżyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
poskarżyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int); cp(że)}
poskarżyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {or}
poskarżyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
poskarżyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
poskarżyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
poskarżyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {or}
poskarżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
poskarżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
poskarżyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int)}
poskarżyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
poskarżyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
poskąpić: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
poskąpić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
poskoczyć: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
poskoczyć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
poskramiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
poskreślać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
poskreślać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poskręcać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poskręcać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poskręcać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poskręcać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
poskręcać się: _: : perf: subj{np(str)} + {xp(adl)}
poskręcać: _: : perf: {np(str)} + {prepnp(z,gen)}
poskręcać: _: : perf: {np(str)} + {xp(locat)}
poskręcać: _: : perf: subj{cp(gdy)} + {np(str)}
poskręcać: _: : perf: subj{cp(jak)} + {np(str)}
poskręcać: _: : perf: subj{cp(kiedy)} + {np(str)}
poskręcać: _: : perf: subj{cp(że)} + {np(str)}
poskręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poskręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poskręcać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poskręcać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poskręcać: _: : perf: subj{np(str)} + {xp(adl)}
poskromić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poskubywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poskubywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poskubywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
poskubywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
poskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
poskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poskutkować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
poskutkować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
posłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
posłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
posłać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
posłować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
posłować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)} + {xp(adl)}
posłować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
posłować: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(w sprawie)} + {xp(adl)}
posłować: _: : imperf: subj{np(str)} + {xp(locat)}
posłuchać się: _: : perf: subj{np(str)} + {np(gen)}
posłuchać: _: : perf: subj{np(str)} + {cp(int)}
posłuchać: _: : perf: subj{np(str)} + {cp(że)}
posłuchać: _: : perf: subj{np(str)} + {np(gen); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
posłuchać: _: : perf: subj{np(str)} + {np(inst)} + {cp(jak)}
posłuchać: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)} + {np(inst)}
posługiwać się: _: : imperf: subj{np(str)} + {np(inst)}
posługiwać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
posługiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
posługiwać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
posługiwać: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
posłużyć się: _: : perf: subj{np(str)} + {np(inst)}
posłużyć: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
posłużyć: _: : perf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {np(dat)}
posłużyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
posłużyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(dla,gen)}
posłużyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
posłużyć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
posłyszeć: _: : perf: subj{np(str)} + {cp(int)}
posłyszeć: _: : perf: subj{np(str)} + {cp(jak)}
posłyszeć: _: : perf: subj{np(str)} + {cp(że)}
posłyszeć: _: : perf: subj{np(str)} + obj{np(str)}
posłyszeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
posmakować: _: : perf: subj{np(str)} + {cp(int)}
posmakować: _: : perf: subj{np(str)} + {np(dat)}
posmakować: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,int)}
posmutnieć: _: : perf: subj{np(str)} + {cp(że)}
posmutnieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
posmutnieć: _: : perf: subj{np(str)} + {or}
posolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posolić: _: : perf: subj{np(str)} + {refl}
pospajać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pospajać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pospajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pospędzać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'oko',natr)}
pospędzać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'powieka',natr)}
pospędzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
pospędzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,inst)}
pospędzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
pospędzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
pospędzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
pospędzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
pospędzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
pospieszyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); xp(adl)}
pospieszyć się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
pospieszyć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
pospieszyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pospieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pospieszyć: _: : perf: subj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(perl)}
pospieszyć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pospisywać: _: : perf: subj{np(str)} + obj{cp(int)}
pospisywać: _: : perf: subj{np(str)} + obj{cp(że)}
pospisywać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
pospisywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
pospisywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
pospisywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
pospisywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
pospisywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
pospisywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
posprowadzać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
posprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
posprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
posprzątać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
posprzątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
posprzątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
posprzątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
pospychać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
pospychać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
posrebrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posrebrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
postać: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
postać: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(w,loc,_,'myśl',atr)}
postać: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
postać: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,_,'myśl',atr)}
postać: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
postać: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'myśl',atr)}
postać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
postać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'myśl',atr)}
postać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)} + {xp(dur)}
postać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(dur)}
postać: _: : perf: subj{np(str)} + {np(dat)} + {xp(dur)} + {xp(locat)}
postać: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(dur)} + {xp(locat)}
postanawiać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
postanawiać: _: : imperf: subj{np(str)} + obj{cp(int)}
postanawiać: _: : imperf: subj{np(str)} + obj{cp(że)}
postanawiać: _: : imperf: subj{np(str)} + obj{cp(żeby)}
postanawiać: _: : imperf: subj{np(str)} + obj{np(str)}
postanawiać: _: : imperf: subj{np(str)} + {or}
postanawiać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
postanowić: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
postanowić: _: : perf: subj{np(str)} + obj{cp(int)}
postanowić: _: : perf: subj{np(str)} + obj{cp(że)}
postanowić: _: : perf: subj{np(str)} + obj{cp(żeby)}
postanowić: _: : perf: subj{np(str)} + obj{np(str)}
postanowić: _: : perf: subj{np(str)} + {or}
postanowić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
postarać się: _: : perf: subj,controller{np(str)} + controllee{prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby); infp(_)}
postawić się: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
postawić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(inst,sg,'sztorc',natr)}
postawić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
postawić się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
postawić: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
postawić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {cp(że)}
postawić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
postawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {prepnp(za,acc)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,sg,'pręgierz',ratr)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',ratr)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
postawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
postawić: _: : perf: subj{np(str)} + {prepadjp(na,loc)}
postawić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
postawić: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
postawić: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
postękać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
postękać: _: : perf: subj{np(str)} + {np(dat)} + {or}
postękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
postękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
postękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
postękać: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
postękać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
postękiwać: _: : imperf: subj{np(str)} + {cp(że)}
postękiwać: _: : imperf: subj{np(str)} + {or}
postękiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
postękiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
postępować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(wobec,gen)}
postępować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(względem,gen)}
postępować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
postępować: _: : imperf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
postępować: _: : imperf: subj{np(str)} + {np(inst)}
postępować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(za,inst)}
postępować: _: : imperf: subj{np(str)} + {np(str)} + {xp(adl)}
postępować: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(za,inst)}
postępować: _: : imperf: subj{np(str)} + {prepnp(według,gen)}
postrzępić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
postrzępić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
postrzępić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
postrzępić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
postrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
postrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
postrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
postrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
postrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
postrzyc się: _: : perf: subj{np(str)} + {xp(locat)} + {advp(misc)}
postrzyc: _: : perf: subj{np(str)} + {lexnp(inst,pl,'ucho',natr)}
postrzyc: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
postrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
postukać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
postukać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
postukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
postukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
postukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
postukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
postukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
postukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
postulować: _: : imperf: subj{np(str)} + obj{cp(żeby)}
postulować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)}
postulować: _: : imperf: subj{np(str)} + {or}
posunąć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
posunąć się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
posunąć się: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
posunąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
posunąć się: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
posunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
posunąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
posuszyć się: _: : perf: subj{np(str)} + {xp(locat)}
posuszyć: _: : perf: {np(str)}
posuszyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {lexnp(str,sg,'głowa',natr)}
posuszyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {lexnp(str,sg,'głowa',natr)}
posuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
posuwać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
posuwać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
posuwać się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
posuwać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
posuwać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
posuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
posuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
posuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
posypać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
posypać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
posypać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
posypać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
posypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posypywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
posypywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
posypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
poszczycić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
poszczycić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
poszczycić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
poszczypać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poszczypać: _: : perf: {np(str)} + {prepnp(w,acc)}
poszczypać: _: : perf: {np(str)} + {xp(locat)}
poszczypać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poszczypać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poszczypać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poszczypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poszczypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
poszczypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poszczypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poszczypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
poszczypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poszerzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poszerzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int)}
poszerzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poszerzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int)}
poszorować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
poszorować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poszorować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poszorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poszorować: _: : perf: subj{np(str)} + {xp(adl)}
posztukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poszturchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poszukać: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,sg,'szczęście',natr)}
poszukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
poszukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poszukać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poszukiwać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {xp(locat)}
poszukiwać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(inst)} + {prepnp(za,acc)}
poszukiwać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
poszybować: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
poszybować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
poszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poszydzić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
poszydzić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
poszydzić: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
poszykować się: _: : perf: subj{np(str)} + {np(dat)}
poszykować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poszykować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
poszykować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
pościelić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pościelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poślinić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poślizgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pośliznąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
poślubiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
poślubić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pośmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
pośmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
pośniedzieć: _: : perf: subj{np(str)} + {np(dat)}
pośpieszyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); xp(adl)}
pośpieszyć się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
pośpieszyć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
pośpieszyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pośpieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pośpieszyć: _: : perf: subj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(perl)}
pośpieszyć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pośpiewać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
pośpiewać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pośpiewać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
pośpiewać: _: : perf: subj{np(str)} + {np(inst)} + {or}
pośpiewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pośredniczyć: _: : imperf: subj{np(str)} + {prepnp(między,inst)} + {prepnp(przy,loc)}
pośredniczyć: _: : imperf: subj{np(str)} + {prepnp(między,inst)} + {prepnp(w,loc)}
pośredniczyć: _: : imperf: subj{np(str)} + {prepnp(pomiędzy,inst)} + {prepnp(przy,loc)}
pośredniczyć: _: : imperf: subj{np(str)} + {prepnp(pomiędzy,inst)} + {prepnp(w,loc)}
poświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
poświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
poświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)}
poświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
poświadczać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)} + {prepnp(przed,inst)}
poświadczać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {cp(int)}
poświadczać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {cp(że)}
poświadczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
poświadczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {prepnp(przed,inst)}
poświadczać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
poświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
poświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
poświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)}
poświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
poświadczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)} + {prepnp(przed,inst)}
poświadczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {cp(int)}
poświadczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {cp(że)}
poświadczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
poświadczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {prepnp(przed,inst)}
poświadczyć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
poświecić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
poświecić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poświęcać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
poświęcać się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
poświęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
poświęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen); prepncp(dla,gen,żeby)}
poświęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
poświęcić się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,żeby)} + {np(inst)}
poświęcić się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
poświęcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
poświęcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen); prepncp(dla,gen,żeby)}
poświęcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
potanieć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
potarzać się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,gen)}
potarzać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
potarzać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
potarzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
potarzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
potarzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
potęgować się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
potęgować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
potęgować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
potęgować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
potępiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {preplexnp(w,acc,sg,'czambuł',natr)}
potępiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
potępić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {preplexnp(w,acc,sg,'czambuł',natr)}
potępić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
potknąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
potknąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
potknąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
potłuc się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
potłuc się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
potłuc się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
potłuc: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
potłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
potłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
potłuc: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
potłumić: _: : perf: subj{np(str)} + obj{np(str)}
potonąć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
potopić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
potopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
potrafić: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
potrafić: _: : imperf: subj{np(str)} + {nonch}
potrajać: _: : imperf: subj{np(str)} + obj{np(str)}
potraktować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
potraktować: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{xp(mod)}
potraktować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
potraktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
potratować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
potrącać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
potrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
potrącać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {lexnp(str,sg,'struna',atr)}
potrącać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(str,sg,'struna',atr)}
potrącić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
potrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
potrącić: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {lexnp(str,sg,'struna',atr)}
potrącić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(str,sg,'struna',atr)}
potrwać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(dur)}
potrzaskać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
potrzaskać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
potrzaskać: _: : perf: {np(dat)} + {xp(locat)}
potrzaskać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
potrzaskać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potrzaskać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
potrzaskać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
potrzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
potrzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
potrzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
potrzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
potrzaskać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
potrzaskiwać: _: : imperf: subj{np(str)} + {np(inst)}
potrzaskiwać: _: : imperf: subj{np(str)} + {xp(locat)}
potrząsać: _: : imperf: subj{np(str)} + {np(inst)}
potrząsać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
potrząsnąć: _: : perf: subj{np(str)} + {np(inst)}
potrząsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
potrzeba: _: : imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
potrzeba: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
potrzeba: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
potrzebować: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
potrzebować: _: : imperf: subj{np(str)} + {np(part)} + {prepnp(dla,gen); prepnp(do,gen); prepnp(na,acc); cp(żeby); prepncp(do,gen,żeby)}
potrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {refl}
potrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
potrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
potrzeć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
potrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
potrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
potrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
potrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
potrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
potrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
potrzepać się: _: : perf: subj{np(str)} + {xp(locat)}
potrzepać: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
potrzepać: _: : perf: subj{np(str)} + {np(inst)} + {or}
potrzepać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potrzepać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
potrzepać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
potrzepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
potrzepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
potrzepać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
potwierdzać się: _: : imperf: subj{cp(że)}
potwierdzać się: _: : imperf: subj{np(str); ncp(str,że)}
potwierdzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
potwierdzać: _: : imperf: subj{np(str)} + {cp(jakoby)}
potwierdzać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
potwierdzać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
potwierdzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
potwierdzać: _: : imperf: subj{np(str)} + {or}
potwierdzić się: _: : perf: subj{cp(że)}
potwierdzić się: _: : perf: subj{np(str); ncp(str,że)}
potwierdzić: _: : perf: subj{np(str)} + {cp(jakoby)}
potwierdzić: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,że)} + {np(inst); ncp(inst,że)}
potwierdzić: _: : perf: subj{np(str)} + {or}
potworzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
potworzyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
potworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
potworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
potykać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
potykać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
potykać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
pouchylać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
pouchylać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
pouchylać się: _: : perf: subj{np(str)} + {xp(adl)}
pouchylać: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(przed,inst)}
pouchylać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
pouczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
pouczyć się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
pouczyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
pouczyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
pouczyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
pouczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pouczyć się: _: : perf: subj{np(str)} + {prepnp(o,loc)}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
pouczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
poukładać się: _: : perf: {np(dat)} + {prepnp(w,loc)} + {advp(misc)}
poukładać się: _: : perf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
poukładać się: _: : perf: subj{np(str)} + {fixed('spać')}
poukładać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poukładać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {advp(misc)}
poukładać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poukładać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poukładać się: _: : perf: subj{np(str)} + {xp(locat)}
poukładać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('spać')}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poukładać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poukręcać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poukręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poukręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
poukrywać się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
poukrywać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
poukrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
poukrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
poupychać się: _: : perf: subj{np(str)} + {xp(adl)}
poupychać się: _: : perf: subj{np(str)} + {xp(locat)}
poupychać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
poupychać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pousadzać się: _: : perf: subj{np(str)} + {xp(locat)}
pousadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pousadzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pousadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pousuwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pousuwać się: _: : perf: subj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)}
pousuwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
pousuwać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)}
pousychać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pousychać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
powalać się: _: : perf: subj{np(str)} + {np(inst)}
powalać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
powalać się: _: : imperf: subj{np(str)} + {xp(adl)}
powalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powalać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
powalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(z,gen,pl,'noga',natr)}
powalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
powalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
powalczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat); prepnp(z,inst)}
powalczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
powalczyć: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(przeciw,dat); prepnp(z,inst)}
powalczyć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
powalczyć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
powalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
powalić się: _: : perf: subj{np(str)} + {xp(adl)}
powalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(z,gen,pl,'noga',natr)}
powalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
powalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
poważnieć: _: : imperf: subj{np(str)} + {np(dat)}
powąchać: _: : perf: subj{np(str)} + {cp(int)} + {refl}
powąchać: _: : perf: subj{np(str)} + {lexnp(str,pl,'kwiatek',natr)} + {preplexnp(od,gen,sg,'spód',natr)}
powąchać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
powąchać: _: : perf: subj{np(str)} + obj{np(str); cp(int)} + {np(dat)}
powątpiewać: _: : imperf: subj{np(str)} + {cp(int)}
powątpiewać: _: : imperf: subj{np(str)} + {cp(że)}
powątpiewać: _: : imperf: subj{np(str)} + {cp(żeby)}
powątpiewać: _: : imperf: subj{np(str)} + {or}
powątpiewać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
powątpiewać: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
powchodzić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
powchodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
powchodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
powchodzić: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
powchodzić: _: : perf: subj{np(str)} + {xp(temp)} + {preplexnp(w,acc,sg,'życie',natr)}
powciągać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
powciągać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powciągać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
powciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
powciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
powciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
powciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
powdzięczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
powdzięczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
poweseleć: _: : perf: subj{np(str)} + {cp(że)}
poweseleć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
poweseleć: _: : perf: subj{np(str)} + {or}
powędrować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
powędrować: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
powędrować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
powędrować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
powędrować: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
powędrować: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
powędrować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powiać: _: : perf: {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powiać: _: : perf: {np(inst)} + {xp(locat)}
powiać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powiadać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {cp(że)}
powiadać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {cp(żeby)}
powiadać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(str)} + {or}
powiadać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)} + {or}
powiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
powiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
powiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
powiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
powiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
powiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
powiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
powiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
powiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
powiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
powiązać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
powiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
powiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
powichrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
powichrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powichrzyć: _: : perf: subj{np(str)} + {prepnp(między,inst)}
powichrzyć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
powichrzyć: _: : perf: subj{np(str)} + {prepnp(wśród,gen)}
powić się: _: : perf: subj{np(str)} + {xp(locat)}
powić się: _: : perf: subj{np(str)} + {xp(temp)}
powić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powielać się: _: : imperf: subj{np(str)}
powielać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
powielić się: _: : perf: subj{np(str)}
powielić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
powierzać: _: : imperf: subj{np(str)} + {np(dat)} + {refl}
powierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
powierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)}
powierzać: _: : imperf: subj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)} + {refl}
powierzyć: _: : perf: subj{np(str)} + {np(dat)} + {refl}
powierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)}
powierzyć: _: : perf: subj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)} + {refl}
powieść się: _: : perf: controller{np(dat)} + controllee{xp(mod)} + {prepnp(w,loc)}
powieść się: _: : perf: subj,controllee{infp(perf)} + controller{np(dat)}
powieść się: _: : perf: subj{np(str)} + {np(dat)}
powieść: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
powieść: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
powieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powiewać: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powiewać: _: : imperf: {np(inst)} + {xp(locat)}
powiewać: _: : imperf: subj{cp(int)} + {np(dat)}
powiewać: _: : imperf: subj{cp(że)} + {np(dat)}
powiewać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
powiewać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powiewać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
powiewać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
powiewać: _: : imperf: subj{np(str)} + {xp(locat)}
powieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
powiększać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powiększać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powiększyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powiększyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powikłać się: _: : perf: subj{np(str)} + {np(dat)}
powikłać: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
powikłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
powinien: _: : imperf: subj,controller{E} + controllee{infp(_)}
powitać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
powitać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
powitać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powitać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
powklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
powklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
powkręcać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
powkręcać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
powkręcać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
powkręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
powkręcać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
powkręcać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
powkręcać: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
powlec się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
powlec się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
powlec się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powlec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
powlec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
powlec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
powlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powlekać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
powlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pownosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pownosić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'obrady',atr)}
pownosić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'adres',atr)}
pownosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
pownosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)} + {xp(adl)}
pownosić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
pownosić: _: : perf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)} + {prepnp(w,loc)}
powodować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
powodować: _: : imperf: subj{np(str); ncp(str,że)} + {np(inst)} + {prepnp(w,loc)}
powodować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)}
powodować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(inst); ncp(inst,że)}
powodzić się: _: : imperf: {np(dat)} + {prepnp(w,loc)} + {xp(mod)}
powodzić się: _: : imperf: subj{np(str)} + {xp(perl)}
powodzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
powodzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
powodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powodzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powołać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
powołać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
powołać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powoływać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
powoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
powoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powozić się: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
powozić się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
powozić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
powozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
powozić: _: : imperf: subj{np(str)} + {np(inst)}
powozić: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
powozić: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
powozić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
powód: : : : {np(gen); ncp(gen,że); ncp(gen,żeby)} + {possp}
powód: : : : {possp} + {cp(że)}
powód: : : : {possp} + {cp(żeby)}
powód: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
powprawiać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
powprawiać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powprawiać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
powprawiać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
powprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
powprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,acc)}
powprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powprowadzać się: _: : perf: subj{np(str)} + {xp(adl)}
powprowadzać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
powprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
powprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
powpychać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powpychać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powracać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
powracać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
powracać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
powrócić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
powrócić: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
powrócić: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
powrócić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(abl)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,_,'ucho',natr)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,sg,'twarz',natr)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,_,'ucho',natr)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(do,gen,_,'ucho',natr)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,sg,'twarz',natr)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,_,'ucho',natr)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'ucho',natr)} + {or}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'twarz',natr)} + {or}
powrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,_,'ucho',natr)} + {or}
powrzeszczeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
powrzeszczeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
powrzeszczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
powskakiwać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
powskakiwać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powstać: _: : perf: subj{np(str)} + {np(dat)}
powstać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powstać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
powstać: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
powstać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powstawać: _: : perf: subj{np(str)} + {xp(abl)}
powstawać: _: : imperf: subj{np(str)} + {np(dat)}
powstawać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powstawać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
powstawać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
powstawać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
powstrzymać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {cp(żeby)}
powstrzymać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
powstrzymać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
powstrzymać: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
powstrzymać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)} + {refl}
powstrzymać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)} + {refl}
powstrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
powstrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
powstrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
powstrzymywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {cp(żeby)}
powstrzymywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
powstrzymywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
powstrzymywać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
powstrzymywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)} + {refl}
powstrzymywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)} + {refl}
powstrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
powstrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
powstrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
powstydzić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
powstydzić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(przed,inst)}
powstydzić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
powstydzić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
powstydzić się: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
powtarzać się: _: : imperf: subj{np(str)}
powtarzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
powtarzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
powtarzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
powtarzać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
powtarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
powtarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
powtarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
powtórzyć się: _: : perf: subj{np(str)}
powtórzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
powtórzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
powtórzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
powtórzyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
powtórzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powtórzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
powtórzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
powybiegać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
powybiegać: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
powybiegać: _: : perf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'myśl',natr)}
powyciągać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powyciągać się: _: : perf: subj{np(str)} + {xp(adl)}
powyciągać się: _: : perf: subj{np(str)} + {xp(locat)}
powyciągać: _: : perf: subj{np(str)} + {cp(że)} + {fixed('na jaw')}
powyciągać: _: : perf: subj{np(str)} + {cp(że)} + {fixed('na światło dzienne')}
powyciągać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen)}
powyciągać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
powyciągać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {fixed('na jaw')}
powyciągać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {fixed('na światło dzienne')}
powyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
powyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(abl)}
powyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(abl)}
powyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {preplexnp(za,acc,pl,'ucho',natr)}
powyciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
powyciągać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
powyciągać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
powyciągać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
powyciągać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
powycinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
powycinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
powycinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
powycinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
powyciskać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)} + {prepnp(z,gen)}
powyciskać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
powyciskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powyciskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
powyciskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
powyciskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
powyciskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powyciskać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
powyciskać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
powyciskać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
powyciskać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
powydawać się: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
powydawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powydawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powydawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powydawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
powydawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
powydłubywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
powydłubywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
powydłubywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
powydobywać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
powydobywać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powydobywać się: _: : perf: subj{np(str)} + {xp(abl)}
powydobywać: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
powydobywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powydobywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
powydobywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powydobywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
powydzielać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powydzielać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powydzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
powydzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
powydzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
powydzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)} + {prepnp(z,gen)}
powydzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
powydziwiać: _: : perf: subj{np(str)} + {cp(int)}
powydziwiać: _: : perf: subj{np(str)} + {or}
powydziwiać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powydziwiać: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
powydziwiać: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
powydziwiać: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
powydziwiać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
powygryzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
powygryzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
powygryzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
powyjadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
powykupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
powykupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
powykupywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
powykupywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
powylatywać: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
powylatywać: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
powylatywać: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
powylatywać: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
powylatywać: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
powylatywać: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
powylatywać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
powylatywać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
powylatywać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powylatywać: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powylatywać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
powylewać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
powylewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
powylewać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
powylewać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
powyłamywać się: _: : perf: subj{np(str)} + {np(dat)}
powyłamywać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
powyłamywać się: _: : perf: subj{np(str)} + {prepnp(spod,gen)}
powyłamywać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powyłamywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
powypędzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powypierać się: _: : perf: subj{np(str)} + {cp(jakoby)}
powypierać się: _: : perf: subj{np(str)} + {cp(że)}
powypierać się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
powypierać się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
powypierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
powypuszczać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
powypuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powyskakiwać: _: : perf: subj{cp(że)} + {np(dat)}
powyskakiwać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
powyskakiwać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
powyskakiwać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
powyskakiwać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powyskakiwać: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
powyskakiwać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(perl)}
powyskakiwać: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
powyskakiwać: _: : perf: subj{or} + {np(dat)}
powystraszać się: _: : perf: subj{np(str)} + {cp(że)}
powystraszać się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)}
powystraszać się: _: : perf: subj{np(str)} + {np(inst)}
powystraszać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
powystraszać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)} + {xp(abl)}
powystraszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(abl)}
powysuwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
powysuwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powysuwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
powyszczerbiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
powyszczerbiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powyszczerbiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
powytaczać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
powytaczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powytaczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
powytaczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
powytaczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powytaczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
powyznaczać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
powyznaczać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
powyznaczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powyznaczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powyznaczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
powziąć: _: : perf: subj{np(str)} + obj{np(str)}
pozabijać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
pozabijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozaczynać się: _: : perf: subj{np(str)} + {np(dat)}
pozaczynać się: _: : perf: subj{np(str)} + {np(inst)}
pozaczynać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
pozaczynać: _: : perf: subj,controller{E} + controllee{infp(imperf)}
pozaczynać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
pozaczynać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pozadawać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pozadawać: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {np(inst)}
pozadawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozadzierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
pozadzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
pozadzierać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pozakładać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pozakładać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pozakładać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
pozakładać: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
pozakładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
pozakładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozakładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pozakrywać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
pozakrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
pozalepiać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pozalepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozamawiać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
pozamawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
pozamawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
pozamawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozamawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
pozamazywać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozamazywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozamiatać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozamiatać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pozamiatać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pozamiatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozamiatać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozaplatać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pozaplatać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pozaplatać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(locat)}
pozaplatać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,acc)}
pozapuszczać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pozapuszczać się: _: : perf: subj{np(str)} + {xp(adl)}
pozapuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
pozapuszczać: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {lexnp(str,sg,'żuraw',natr)}
pozapuszczać: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(str,pl,'korzeń',natr)}
pozarażać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
pozarażać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
pozarażać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozarzucać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
pozarzucać: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
pozarzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozarzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozarzucać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
pozarzynać się: _: : perf: subj{np(str)} + {advp(misc)}
pozarzynać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pozarzynać się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
pozarzynać: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
pozarzynać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozasiadać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pozasiadać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pozasiadać: _: : perf: subj{np(str)} + {xp(locat)}
pozasypiać: _: : perf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
pozasypiać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozasypiać: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
pozasypiać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pozasypiać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pozasypywać się: _: : perf: subj{np(str)} + {np(dat)}
pozasypywać: _: : perf: {np(dat)} + {np(inst)} + {np(str)}
pozasypywać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pozasypywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozasypywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozasypywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozasypywać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pozatrzaskiwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozatrzaskiwać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pozatrzaskiwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
pozatrzaskiwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozatrzaskiwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
pozatrzaskiwać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pozawiązywać się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
pozawiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozawiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozawiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozazdrościć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pozazdrościć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,int); ncp(gen,że)}
pozaziębiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozaziębiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pozbawiać: _: : imperf: subj{np(str)} + {np(gen)} + {refl}
pozbawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(gen)}
pozbawić się: _: : perf: subj{np(str)} + {np(gen)}
pozbawić: _: : perf: subj{np(str)} + {np(gen)} + {refl}
pozbawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(gen)}
pozbiegać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'czas',natr)}
pozbiegać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pozbiegać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
pozbiegać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
pozbiegać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozbierać się: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)} + {advp(misc)}
pozbierać się: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)} + {preplexnp(do,gen,sg,'kupa',natr)}
pozbierać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pozbierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
pozbierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
pozbierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
pozbyć się: _: : perf: subj{np(str)} + {np(gen)} + {xp(abl)}
pozbywać się: _: : imperf: subj{np(str)} + {np(gen)} + {xp(abl)}
pozdrawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozdrawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
pozdrawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pozdrawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozeskakiwać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
pozgarniać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
pozgarniać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pozginać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
pozginać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pozginać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
pozginać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozginać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
pozginać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pozginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
pozginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
pozginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozginać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
pozginać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pozłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozłocić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozmiatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
pozmywać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pozmywać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
pozmywać: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
pozmywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
pozmywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pozmywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
poznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poznać się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
poznać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poznać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poznać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
poznać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
poznać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
poznać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
poznawać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
poznawać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
poznawać: _: : imperf: subj{np(str)} + {cp(jeśli)}
poznawać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
poznawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poznawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
poznawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
poznawać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
poznawać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
poznosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poznosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozostać: _: : perf: controller{np(dat)} + controllee{infp(_)}
pozostać: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
pozostać: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
pozostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pozostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
pozostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
pozostać: _: : perf: subj{np(str)} + {prepnp(bez,gen)}
pozostać: _: : perf: subj{np(str)} + {prepnp(między,inst)}
pozostać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pozostać: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że)}
pozostać: _: : perf: subj{np(str)} + {xp(locat)}
pozostawać: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
pozostawać: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
pozostawać: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
pozostawać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
pozostawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
pozostawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
pozostawać: _: : imperf: subj{np(str)} + {prepnp(bez,gen)}
pozostawać: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
pozostawać: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że)}
pozostawać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,loc,sg,'tył',natr)}
pozostawać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(z,gen,sg,'tył',natr)}
pozostawać: _: : imperf: subj{np(str)} + {xp(locat)}
pozostawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozostawiać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',atr)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
pozostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
pozostawić: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',atr)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
pozostawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
pozować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)}
pozować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pozować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
pozór: : : : {cp(jakoby)}
pozór: : : : {cp(że)}
pozór: : : : {np(gen); ncp(gen,int); ncp(gen,że)}
pozrażać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
pozrażać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen)}
pozrażać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)}
pozrażać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
pozrzucać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(po,acc)}
pozrzucać się: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {cp(żeby)}
pozrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
pozrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozsiadać się: _: : perf: subj{np(str)}
pozsiadać: _: : perf: subj{np(str)} + {xp(abl)}
pozsuwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozsuwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
pozwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pozwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
pozwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pozwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozwalać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{prepnp(na,acc); cp(żeby); prepncp(na,acc,że); prepncp(na,acc,żeby); infp(_)}
pozwalać: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
pozwiązywać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pozwiązywać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
pozwiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozwiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pozwiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pozwolić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{prepnp(na,acc); cp(żeby); prepncp(na,acc,że); prepncp(na,acc,żeby); infp(_)}
pozwolić: _: : perf: subj{np(str)} + {cp(że)}
pozwolić: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
pozwolić: _: : perf: subj{np(str)} + {np(gen)}
pozwolić: _: : perf: subj{np(str)} + obj{np(str)}
pozwolić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pozwolić: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pozwoływać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pozwoływać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pozwoływać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
pozwoływać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pozwracać się: _: : perf: subj{np(str)} + {np(dat)}
pozwracać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
pozwracać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
pozwracać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
pozwracać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
pozwracać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
pozwracać się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
pozwracać się: _: : perf: subj{np(str)} + {xp(adl)}
pozwracać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {lexnp(str,sg,'uwaga',atr)}
pozwracać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'uwaga',atr)}
pozwracać: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'uwaga',atr)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pozwracać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pozwracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozwracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
pozwracać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozycjonować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
pozycjonować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
pozycjonować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
pozycjonować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pozycjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozycjonować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
pozyskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pozyskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozyskać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pozyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pozywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
pozywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pozywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pożalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
pożalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
pożalić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
pożalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
pożalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pożalić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
pożalić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
pożalić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pożalić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
pożalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
pożalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
pożałować: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
pożałować: _: : perf: subj{np(str)} + {np(gen); cp(że); ncp(gen,że)}
pożałować: _: : perf: subj{np(str)} + {np(gen)} + {or}
pożądać: _: : imperf: subj{np(str)} + obj{cp(żeby)}
pożądać: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,żeby)}
pożeglować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
pożeglować: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pożeglować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pożeglować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pożeglować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
pożegnać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,inst)}
pożegnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pożenić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pożenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pożerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pożółknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pożółknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pożreć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pożreć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pożyczać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
pożyczać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(u,gen)}
pożyczać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
pożyczać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pożyczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
pożyczyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
pożyczyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
pożyczyć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczyć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(u,gen)}
pożyczyć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
pożyć: _: : perf: subj{np(str)} + {np(inst)}
pożyć: _: : perf: subj{np(str)} + {preplexnp(na,loc,pl,'walizka',natr)}
pożyć: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
pożyć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pożyć: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
pożyć: _: : perf: subj{np(str)} + {xp(dur)}
pożyć: _: : perf: subj{np(str)} + {xp(locat)}
pożywiać się: _: : imperf: subj{np(str)} + {np(inst)} + {advp(misc)}
pożywiać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
pożywiać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
pożywiać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
pożywiać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pożywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pożywić się: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)}
pożywić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pożywić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pożywić się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
pożywić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pożywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pójść: _: : perf: controller{np(dat)} + controllee{xp(mod)}
pójść: _: : perf: {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr); preplexnp(w,acc,pl,'noga',natr)}
pójść: _: : perf: {np(dat)} + {preplexnp(w,acc,pl,'pięta',natr)}
pójść: _: : perf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
pójść: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
pójść: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pójść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
pójść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ręka',natr)}
pójść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'zdrowie',natr)}
pójść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'noga',natr)}
pójść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'pięta',natr)}
pójść: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pójść: _: : perf: subj{np(str)} + {preplexnp(w,acc,pl,'ślad',ratr)}
pójść: _: : perf: subj{np(str)} + {preplexnp(z,inst,pl,'torba',natr)}
pójść: _: : perf: subj{np(str)} + {preplexnp(z,inst,sg,'dym',natr)}
pójść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pójść: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pójść: _: : perf: subj{np(str)} + {prepnp(po,acc)}
pójść: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pójść: _: : perf: subj{np(str)} + {prepnp(za,acc)}
pójść: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pójść: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,acc,sg,'ogień',natr)}
pójść: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)} + {preplexnp(o,acc,sg,'zakład',natr)}
pójść: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {fixed('na udry')}
pójść: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'łóżka',natr)}
pójść: _: : perf: subj{np(str)} + {xp(adl)}
pójść: _: : perf: subj{np(str)} + {xp(perl)}
pracować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
pracować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
pracować: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
pracować: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
pracować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pracować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
pracować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
pracować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
pracować: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
pracować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
pragnąć: _: : imperf: subj,controller{np(str)} + controllee{cp(żeby); infp(_)}
pragnąć: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
praktykować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)}
praktykować: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
praktykować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
praktykować: _: : imperf: subj{np(str)} + {xp(locat)}
prasować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prawda: : : : {possp} + {comprepnp(na temat)}
prawda: : : : {possp} + {comprepnp(w kwestii)}
prawda: : : : {possp} + {comprepnp(w sprawie)}
prawda: : : : {possp} + {cp(jakoby)}
prawda: : : : {possp} + {cp(że)}
prawda: : : : {possp} + {cp(żeby)}
prawda: : : : {possp} + {fixed('święta')}
prawda: : : : {possp} + {or}
prawda: : : : {possp} + {prepnp(co do,gen)}
prawda: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
prawda: : : : {possp} + {prepnp(wobec,gen)}
prawda: : : : {possp} + {prepnp(względem,gen)}
prawić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
prawić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
prawić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
prawić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
prawić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
prawić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
prawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
prawo: : : : {np(gen); prepnp(do,gen); ncp(gen,że); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {possp}
prawo: : : : {possp} + {comprepnp(co do)}
prawo: : : : {possp} + {comprepnp(na temat)}
prawo: : : : {possp} + {comprepnp(w kwestii)}
prawo: : : : {possp} + {comprepnp(w sprawie)}
prawo: : : : {possp} + {cp(że)}
prawo: : : : {possp} + {cp(żeby)}
prawo: : : : {possp} + {or}
prawo: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
prawo: : : : {prepnp(dla,gen)}
prażyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
prażyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
prażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
prażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
prażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
prażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(abl)}
prażyć: _: : imperf: subj{np(str)} + {xp(locat)}
prąd: : : : {adjp(agr)} + {possp} + {prepnp(w,loc)}
prątkować: _: : imperf: subj{np(str)} + {np(inst)}
precyzować się: _: : imperf: subj{np(str)}
precyzować: _: : imperf: subj{np(str)} + obj{cp(int)}
precyzować: _: : imperf: subj{np(str)} + obj{cp(że)}
precyzować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
precyzować: _: : imperf: subj{np(str)} + {or}
predestynować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {cp(żeby)}
predestynować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
predestynować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)}
predysponować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
predysponować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
preferować: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
preferować: _: : imperf: subj{np(str)} + {cp(gdy)}
preferować: _: : imperf: subj{np(str)} + {cp(jak)}
preferować: _: : imperf: subj{np(str)} + {cp(jeśli)}
preferować: _: : imperf: subj{np(str)} + {cp(kiedy)}
preferować: _: : imperf: subj{np(str)} + {cp(żeby)}
preferować: _: : imperf: subj{np(str)} + obj{np(str)}
premiować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
premiować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
prenumerować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
prenumerować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
prenumerować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
preparować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
preparować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
preparować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
preparować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pretendować: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
prezentować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
prezentować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,loc)}
prezentować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
prezentować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
prezentować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
prezentować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
prężyć się: _: : imperf: subj{np(str)}
prężyć: _: : imperf: subj{np(str)} + obj{np(str)}
problem: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)} + {possp}
problem: : : : {possp} + {cp(int)}
problem: : : : {possp} + {cp(że)}
problem: : : : {possp} + {cp(żeby)}
problem: : : : {possp} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
problem: : : : {possp} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)} + {comprepnp(z powodu)}
problem: : : : {prepnp(dla,gen)}
procedować: _: : imperf: subj{np(str)} + obj{np(str)}
procedować: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
produkować się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
produkować się: _: : imperf: subj{np(str)} + {or}
produkować się: _: : imperf: subj{np(str)} + {xp(locat)}
produkować: _: : imperf: subj{np(str)} + obj{np(str)}
profesor: : : : {np(gen)} + {possp}
profesor: : : : {np(gen); xp(locat)} + {adjp(agr)}
profesor: : : : {possp} + {preplexnp(w,loc,sg,'zakres',atr)}
profesor: : : : {possp} + {preplexnp(z,gen,sg,'zakres',atr)}
profesor: : : : {possp} + {prepnp(od,gen)}
profesor: : : : {possp} + {prepnp(z,gen)}
profilować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prognozować: _: : imperf: subj{np(str)} + obj{cp(int)}
prognozować: _: : imperf: subj{np(str)} + obj{cp(że)}
prognozować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
programować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
programować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
programować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
programować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
projektować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
projektować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
projektować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
proklamować: _: : _: subj,controller{np(str)} + controllee{np(inst)} + {refl}
proklamować: _: : _: subj{np(str)} + {cp(że)}
proklamować: _: : _: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
proklamować: _: : _: subj{np(str)} + obj{np(str); ncp(str,że)}
promienieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
promienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
promienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
promienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
promienieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
promieniować: _: : imperf: subj{np(str)} + {np(inst)}
promieniować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
promieniować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
promieniować: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
promieniować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
promieniować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
promować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
promować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
promować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
promować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
promować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
promować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
propagować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
proponować: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
proponować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
proponować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
proponować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); cp(żeby); ncp(str,żeby)} + {np(dat)}
proponować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
proponować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
propozycja: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)} + {possp}
propozycja: : : : {possp} + {comprepnp(na temat)}
propozycja: : : : {possp} + {comprepnp(w kwestii)}
propozycja: : : : {possp} + {comprepnp(w sprawie)}
propozycja: : : : {possp} + {cp(int)}
propozycja: : : : {possp} + {cp(że); cp(żeby)}
propozycja: : : : {possp} + {or}
propozycja: : : : {possp} + {prepnp(dla,gen)} + {prepnp(do,gen)}
propozycja: : : : {possp} + {prepnp(dla,gen)} + {prepnp(na,acc)}
prorokować: _: : imperf: subj{np(str)} + {comprepnp(co do)}
prorokować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
prorokować: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(na,acc)} + {advp(misc)}
prorokować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
prorokować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
prorokować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
prorokować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
prorokować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
prorokować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
prosić się: _: : imperf: subj{np(str)} + {cp(żeby)}
prosić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
prosić: _: : imperf: {np(gen)}
prosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
prosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
prosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,żeby)}
prosić: aff: : imperf: subj,controller{np(str)} + controllee{infp(_)}
prosperować: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
prostować się: _: : imperf: subj{np(str)} + {np(dat)}
prostować: _: : imperf: subj{np(str)} + {cp(że)}
prostować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
prostować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prostować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
protest: : : : {possp} + {prepnp(co do,gen)} + {prepnp(do,gen)}
protest: : : : {possp} + {prepnp(do,gen)} + {comprepnp(na temat)}
protest: : : : {possp} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
protest: : : : {possp} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
protest: : : : {possp} + {prepnp(do,gen)} + {comprepnp(z powodu)}
protest: : : : {possp} + {prepnp(do,gen)} + {cp(jakoby)}
protest: : : : {possp} + {prepnp(do,gen)} + {cp(że)}
protest: : : : {possp} + {prepnp(do,gen)} + {cp(żeby)}
protest: : : : {possp} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
protest: : : : {possp} + {prepnp(do,gen)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
protest: : : : {possp} + {prepnp(do,gen)} + {prepnp(wobec,gen); prepncp(wobec,gen,że)}
protest: : : : {possp} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
protestować: _: : imperf: subj{np(str)} + {cp(że)}
protestować: _: : imperf: subj{np(str)} + {cp(żeby)}
protestować: _: : imperf: subj{np(str)} + {or}
protestować: _: : imperf: subj{np(str)} + {prepncp(przeciw,dat,jakoby)}
protestować: _: : imperf: subj{np(str)} + {prepncp(przeciw,dat,żeby)}
protestować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że)}
prowadzić się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
prowadzić: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
prowadzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
prowadzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
prowadzić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
prowadzić: _: : imperf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
prowadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
prowadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
prowadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'sznurek',natr)}
prowadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
prowadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
prowadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
prowadzić: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
prowadzić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
prowadzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
prowokować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
prowokować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {cp(żeby)}
prowokować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
próbować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
próbować: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
próbować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'siła',batr)}
próbować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'szczęście',atr)}
próbować: _: : imperf: subj{np(str)} + {cp(czy)}
próbować: _: : imperf: subj{np(str)} + {np(gen)}
próbować: _: : imperf: subj{np(str)} + obj{np(str)}
próbować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,pl,'siła',batr)}
próbować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,sg,'szczęście',atr)}
próbować: _: : imperf: subj{np(str)} + {xp(locat)} + {lexnp(gen,pl,'siła',batr)}
próbować: _: : imperf: subj{np(str)} + {xp(locat)} + {lexnp(gen,sg,'szczęście',atr)}
próchnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
próchnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
prószyć: _: : imperf: {np(inst)} + {xp(abl)}
prószyć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
prószyć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
próżnować: _: : imperf: subj{np(str)}
pruć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pruć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pruć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
pruć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pruć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
pruć: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pruć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {cp(że)}
pruć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {or}
pruć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {cp(że)}
pruć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {or}
pruć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pruć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pruć: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,gen)}
pruć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
pruć: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
prychać: _: : imperf: subj{np(str)} + {nonch}
prychać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {or}
prychać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
prychać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
prychać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
prychać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
prychać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
prychnąć: _: : perf: subj{np(str)} + {nonch}
prychnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {or}
prychnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
prychnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
prychnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
prychnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
prychnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
pryskać się: _: : imperf: subj{np(str)} + {xp(locat)}
pryskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
pryskać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
pryskać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
prysnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
prysnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
prysnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
prywatyzować się: _: : imperf: subj{np(str)}
prywatyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przeanalizować: _: : perf: subj{np(str)} + obj{cp(int)}
przeanalizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
przebaczać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przebaczać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przebaczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przebaczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przebaczyć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przebaczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przebadać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przebadać się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
przebadać się: _: : perf: subj{np(str)} + {xp(locat)}
przebadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przebadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przebadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przebąkiwać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przebąkiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
przebąknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
przebąknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
przebić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przebić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
przebić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przebić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przebić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(inst)}
przebić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przebiec się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
przebiec się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przebiec: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
przebiec: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(przez,acc)}
przebiec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
przebiec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {or}
przebiec: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
przebiec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przebiec: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przebiec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebiec: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebiec: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przebiegać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
przebiegać: _: : perf: subj{np(str)} + obj{np(str)}
przebiegać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
przebiegać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
przebiegać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przebiegać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(po,loc)}
przebiegać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebiegać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebiegać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przebiegać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przebiegać: _: : imperf: subj{np(str)} + {xp(perl)}
przebierać: _: : imperf: subj{np(str)} + {np(inst)}
przebierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przebierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przebierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
przebierać: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'noga',natr)} + {preplexnp(z,gen,sg,'noga',natr)}
przebierać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przebierać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)} + {refl}
przebierać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przebierać: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)}
przebierać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
przebijać się: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(w,loc)}
przebijać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przebijać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
przebijać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przebijać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
przebijać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przebijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przebijać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przebijać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przebijać: _: : imperf: subj{np(str)} + {xp(abl)}
przebrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
przebrać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przebrać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)} + {refl}
przebrać: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
przebrnąć: _: : perf: subj{np(str)} + {np(str)}
przebrnąć: _: : perf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int)}
przebrnąć: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
przebronować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przebrzmieć: _: : perf: subj{cp(że)} + {xp(locat)}
przebrzmieć: _: : perf: subj{np(str)} + {xp(locat)}
przebrzmiewać: _: : imperf: subj{cp(że)} + {xp(locat)}
przebrzmiewać: _: : imperf: subj{np(str)} + {xp(locat)}
przebudować się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przebudować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebudować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przebudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebudzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przebudzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przebudzić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
przebudzić się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
przebudzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przebudzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
przebudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przebudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przebudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
przebudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)} + {xp(locat)}
przecedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przecedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przecedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przecedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przecedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przecedzić: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(przez,acc,pl,'ząb',natr)}
przecedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przecedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przecedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przecedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przecedzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przecedzić: _: : perf: subj{np(str)} + {preplexnp(przez,acc,pl,'ząb',natr)} + {or}
przeceniać się: _: : imperf: subj{np(str)}
przeceniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przeceniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeceniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przeceniać: _: : imperf: subj{np(str)} + {refl}
przecenić się: _: : perf: subj{np(str)}
przecenić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przecenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przecenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przecenić: _: : perf: subj{np(str)} + {refl}
przechodzić: _: : perf: subj{np(str)} + obj{np(str)}
przechodzić: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przechodzić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przechodzić: _: : imperf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przechodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
przechodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(między,inst)}
przechodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
przechodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przechodzić: _: : imperf: subj{np(str)} + {np(inst)}
przechodzić: _: : imperf: subj{np(str)} + obj{np(str)}
przechodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)} + {prepnp(od,gen)}
przechodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przechodzić: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przechodzić: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(w,acc)}
przechodzić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przechować się: _: : perf: subj{np(str)} + {xp(dur)}
przechować się: _: : perf: subj{np(str)} + {xp(locat)}
przechować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przechować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przechowywać się: _: : imperf: subj{np(str)} + {xp(dur)}
przechowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
przechowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przechowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przechrzcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przechrzcić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {refl}
przechwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przechwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
przechwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przechwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
przechwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przechwalać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)} + {prepnp(przed,inst)}
przechwalać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
przechwalać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(jak)}
przechwalać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
przechwalać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
przechwalać: _: : imperf: subj{np(str)} + obj{np(str)}
przechwycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przechwytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przechylać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przechylać się: _: : imperf: subj{np(str)} + {xp(adl)}
przechylać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przechylać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przechylić się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przechylić się: _: : perf: subj{np(str)} + {xp(adl)}
przechylić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przechylić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przeciąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przeciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przeciągać się: _: : imperf: subj{np(str)} + {xp(dur)}
przeciągać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przeciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przeciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przeciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przeciągać: _: : imperf: subj{np(str)} + {xp(perl)}
przeciągnąć się: _: : perf: subj{np(str)} + {xp(dur)}
przeciągnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przeciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przeciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przeciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przeciągnąć: _: : perf: subj{np(str)} + {xp(perl)}
przeciążać się: _: : imperf: subj{np(str)} + {np(inst)}
przeciążać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeciążyć się: _: : perf: subj{np(str)} + {np(inst)}
przeciążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przecierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {xp(locat)}
przecierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
przecierać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
przecierać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
przecierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przecierać się: _: : imperf: {xp(locat)}
przecierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przecierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przecierpieć: _: : perf: subj{np(str)} + {cp(int)}
przecierpieć: _: : perf: subj{np(str)} + {cp(że)}
przecierpieć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przecinać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przecinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przeciskać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przeciskać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przeciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przecisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przecisnąć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przecisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przecisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeciwdziałać: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
przeciwstawiać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
przeciwstawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przeciwstawić się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
przeciwstawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przeczekać: _: : perf: subj{np(str)} + {cp(aż)}
przeczekać: _: : perf: subj{np(str)} + obj{np(str)}
przeczekać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przeczekiwać: _: : imperf: subj{np(str)} + {cp(aż)}
przeczekiwać: _: : imperf: subj{np(str)} + obj{np(str)}
przeczekiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przeczesać się: _: : perf: subj{np(str)}
przeczesać się: _: : perf: subj{np(str)} + {xp(perl)}
przeczesać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przeczesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeczesywać się: _: : imperf: subj{np(str)}
przeczesywać się: _: : imperf: subj{np(str)} + {xp(perl)}
przeczesywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przeczesywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeczyć: _: : imperf: subj{np(str)} + {cp(jakoby)}
przeczyć: _: : imperf: subj{np(str)} + {cp(że)}
przeczyć: _: : imperf: subj{np(str)} + {ncp(dat,jakoby)}
przeczyć: _: : imperf: subj{np(str)} + {ncp(dat,że)}
przeczyć: _: : imperf: subj{np(str)} + {ncp(dat,żeby)}
przeczyć: _: : imperf: subj{np(str)} + {np(dat)}
przeczyszczać: _: : imperf: {np(str)} + {prepnp(od,gen)}
przeczyszczać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przeczyszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeczyszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przeczyszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przeczyszczać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
przeczyścić: _: : perf: {np(str)} + {prepnp(od,gen)}
przeczyścić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przeczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przeczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przeczyścić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
przeczytać: _: : perf: subj{np(str)} + {cp(żeby)}
przeczytać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przeczytać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przeczytać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
przeczytać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
przeczytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przeczytać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {cp(int)}
przeczytać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
przeczytać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {or}
przeć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeć: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przeć: _: : imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
przeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
przeć: _: : imperf: subj{np(str)} + {xp(adl)}
przećwiczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
przećwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przećwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przećwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przećwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przedawkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przedawniać się: _: : imperf: subj{np(str)} + {np(dat)}
przedawniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przedawnić się: _: : perf: subj{np(str)} + {np(dat)}
przedawnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przedkładać: _: : imperf: subj{np(str)} + {cp(że); cp(żeby)}
przedkładać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedkładać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {xp(locat)}
przedkładać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedkładać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(locat)}
przedkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
przedkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
przedłożyć: _: : perf: subj{np(str)} + {cp(że); cp(żeby)}
przedłożyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedłożyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {xp(locat)}
przedłożyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedłożyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(locat)}
przedłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
przedłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
przedłużać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
przedłużać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przedłużyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
przedłużyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przedostać się: _: : perf: subj{cp(że)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostawać się: _: : imperf: subj{cp(że)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostawać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przedrzeć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przedrzeć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przedrzeźniać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przedrzeźniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
przedsiębrać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
przedsiębrać: _: : imperf: subj{np(str)} + obj{np(str)}
przedsięwziąć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
przedsięwziąć: _: : perf: subj{np(str)} + obj{np(str)}
przedstawiać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedstawiać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
przedstawiać się: _: : imperf: subj{cp(że)} + {np(dat)}
przedstawiać się: _: : imperf: subj{np(str)} + {lexnp(dat,pl,'oko',atr)}
przedstawiać się: _: : imperf: subj{np(str)} + {np(dat)}
przedstawiać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
przedstawiać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
przedstawiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {refl}
przedstawiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedstawiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedstawić się: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
przedstawić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
przedstawić się: _: : perf: subj{cp(że)} + {np(dat)}
przedstawić się: _: : perf: subj{np(str)} + {lexnp(dat,pl,'oko',atr)}
przedstawić się: _: : perf: subj{np(str)} + {np(dat)}
przedstawić: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
przedstawić: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
przedstawić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {refl}
przedstawić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedstawić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedyskutować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
przedzierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przedzierać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przedzierać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przeforsować się: _: : perf: subj{np(str)}
przeforsować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeforsować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przeforsować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przeganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'wiatr',atr)}
przeganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przegapiać: _: : imperf: subj{np(str)} + {cp(gdy)}
przegapiać: _: : imperf: subj{np(str)} + {cp(jak)}
przegapiać: _: : imperf: subj{np(str)} + {cp(kiedy)}
przegapiać: _: : imperf: subj{np(str)} + {cp(że)}
przegapiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
przegapić: _: : perf: subj{np(str)} + {cp(gdy)}
przegapić: _: : perf: subj{np(str)} + {cp(jak)}
przegapić: _: : perf: subj{np(str)} + {cp(kiedy)}
przegapić: _: : perf: subj{np(str)} + {cp(że)}
przegapić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
przeglądać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przeglądać: _: : imperf: subj{np(str)} + obj{np(str)}
przeglądać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przegłosować: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
przegłosować: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
przegłosować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(inst)}
przegłosować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
przegnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przegnać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'wiatr',atr)}
przegonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przegonić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'wiatr',atr)}
przegonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przegotować się: _: : perf: subj{np(str)} + {np(dat)}
przegotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przegrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przegrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przegrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przegrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przegrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przegrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przegrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przegryzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {xp(adl)}
przegryzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przegryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przegryźć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {xp(adl)}
przegryźć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przegryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przegrzać się: _: : perf: subj{np(str)} + {np(dat)}
przegrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przegrzewać się: _: : imperf: subj{np(str)} + {np(dat)}
przegrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przehandlować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(dla,gen)}
przehandlować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przehandlować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
przehandlować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przehandlowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(dla,gen)}
przehandlowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przehandlowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
przehandlowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przeinaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeinaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeistaczać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistaczać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeistaczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeistoczyć się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistoczyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeistoczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przejawiać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
przejawiać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
przejawiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
przejawiać się: _: : imperf: subj{np(str)} + {np(inst); prepnp(w,loc); ncp(inst,int); ncp(inst,że); ncp(inst,żeby); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przejawiać: _: : imperf: subj{np(str)} + obj{np(str)}
przejawić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
przejawić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
przejawić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
przejawić się: _: : perf: subj{np(str)} + {np(inst); prepnp(w,loc); ncp(inst,int); ncp(inst,że); ncp(inst,żeby); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przejawić: _: : perf: subj{np(str)} + obj{np(str)}
przejąć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przejąć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
przejąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
przejąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,acc)}
przejąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przejechać się: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
przejechać się: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(perl)}
przejechać się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
przejechać się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
przejechać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
przejechać: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przejechać: _: : perf: subj{np(str)} + {np(str)} + {xp(perl)}
przejechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)}
przejeżdżać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
przejeżdżać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
przejeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
przejeżdżać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przejeżdżać: _: : imperf: subj{np(str)} + {np(str)} + {xp(perl)}
przejeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)}
przejmować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przejmować: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
przejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
przejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,acc)}
przejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przejrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przejrzeć: _: : perf: subj{np(str)} + {cp(int)} + {preplexnp(na,acc,pl,'oko',natr)}
przejrzeć: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'oko',natr)}
przejrzeć: _: : perf: subj{np(str)} + obj{np(str)}
przejrzeć: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przejść się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przejść się: _: : perf: subj{np(str)} + {xp(adl)}
przejść się: _: : perf: subj{np(str)} + {xp(perl)}
przejść: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: _: : perf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
przejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(między,inst)}
przejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
przejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przejść: _: : perf: subj{np(str)} + {np(inst)}
przejść: _: : perf: subj{np(str)} + {np(str)}
przejść: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)} + {prepnp(od,gen)}
przejść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przejść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przejść: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(w,acc)}
przejść: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekazać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {cp(że); cp(żeby)}
przekazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
przekazać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
przekazywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {cp(że); cp(żeby)}
przekazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
przekazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
przekierować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przekląć: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
przekląć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,że)}
przekląć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
przekląć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
przekląć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
przekląć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przekląć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
przeklinać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
przeklinać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,że)}
przeklinać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
przeklinać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
przeklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
przeklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przeklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
przekonać się: _: : perf: subj{np(str)} + {cp(int); cp(że)}
przekonać się: _: : perf: subj{np(str)} + {cp(żeby)}
przekonać się: _: : perf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,że)}
przekonać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przekonać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
przekonać: _: : perf: subj{np(str); cp(że); ncp(str,że)} + {np(str)}
przekonać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
przekonać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); cp(int); cp(że); cp(żeby); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przekonać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przekonywać się: _: : imperf: subj{np(str)} + {cp(int)}
przekonywać się: _: : imperf: subj{np(str)} + {cp(że)}
przekonywać się: _: : imperf: subj{np(str)} + {or}
przekonywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przekonywać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
przekonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
przekonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przekonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
przekonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,żeby)}
przekonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
przekonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
przekonywać: _: : imperf: subj{np(str)} + {or}
przekoziołkować się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
przekoziołkować się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
przekoziołkować się: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przekoziołkować: _: : perf: {np(str)}
przekoziołkować: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
przekoziołkować: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
przekoziołkować: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przekoziołkować: _: : perf: subj{np(str)} + obj{np(str)}
przekraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przekradać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekradać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekraść się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekraść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekreślać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przekreślić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przekręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {xp(adl)}
przekręcać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {xp(adl)}
przekręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przekręcić się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przekręcić się: _: : perf: subj{nonch} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przekręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {xp(adl)}
przekręcić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {xp(adl)}
przekręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przekroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przekroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przekrzyczeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przekrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
przekrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
przekrzykiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przekrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
przekrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
przekształcać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przekształcać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przekształcać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekształcać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przekształcać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przekształcać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przekształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przekształcić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przekształcić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przekształcić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekształcić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przekształcić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przekształcić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przekształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przekupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przekupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przekwalifikować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekwalifikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przekwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekwalifikowywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekwalifikowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przekwalifikowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przelać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przelać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przelać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
przelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przelatywać: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
przelatywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przelatywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przelatywać: _: : imperf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: _: : imperf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelecieć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przelecieć: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przelecieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przelecieć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przelecieć: _: : perf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: _: : perf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelewać się: _: : imperf: {np(dat)}
przelewać się: _: : imperf: {prepnp(u,gen)}
przelewać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przelewać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przelewać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelewać się: _: : imperf: {xp(locat)}
przelewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przelewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
przelewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przeleżeć: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przeliczać się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
przeliczać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przeliczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przeliczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przeliczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przeliczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przeliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przeliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przeliczyć się: _: : perf: subj{np(str)} + {comprepnp(co do)}
przeliczyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
przeliczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przeliczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przeliczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przeliczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przeliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przeliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przelobować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przelobować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
przeładować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeładować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przeładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przełamać się: _: : perf: subj{np(str)} + {cp(żeby)}
przełamać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przełamać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przełamać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przełamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przełamywać się: _: : imperf: subj{np(str)} + {cp(żeby)}
przełamywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przełamywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przełamywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
przełamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przełknąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
przełykać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
przemaszerować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przemawiać się: _: : imperf: subj{np(str)} + {or}
przemawiać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
przemawiać: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)}
przemawiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przemawiać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
przemawiać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przemęczać się: _: : imperf: subj{np(str)} + {np(inst)}
przemęczać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
przemęczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przemęczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przemęczać się: _: : imperf: subj{np(str)} + {xp(locat)}
przemęczać: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
przemęczyć się: _: : perf: subj{np(str)} + {np(inst)}
przemęczyć się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
przemęczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przemęczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przemęczyć się: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przemęczyć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
przemęczyć: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
przemianować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemianować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {refl}
przemieniać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemieniać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemieniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemieniać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemienić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemienić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemienić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemieszać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
przemieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przemieszczać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przemieszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przemijać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
przemijać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przemilczać: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
przemilczać: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(wobec,gen)}
przemilczać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
przemilczać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(wobec,gen)}
przemilczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
przemilczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(wobec,gen)}
przemilczeć: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
przemilczeć: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(wobec,gen)}
przemilczeć: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
przemilczeć: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(wobec,gen)}
przemilczeć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
przemilczeć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(wobec,gen)}
przeminąć: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
przeminąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przemoczyć się: _: : perf: subj{np(str)} + {np(dat)}
przemoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przemóc się: _: : perf: subj{np(str)} + {cp(żeby)}
przemóc się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przemóc się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przemóc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przemóc: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,_,'siebie',natr)}
przemóc: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
przemówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przemówić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
przemówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przemówić: _: : perf: subj{np(str)} + {prepncp(za,inst,żeby)}
przemówić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,inst)}
przemówić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przemówić: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
przemówić: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przemówić: _: : perf: subj{np(str)} + {prepnp(za,inst)}
przemyśleć: _: : perf: subj{np(str)} + {cp(int)}
przemyśleć: _: : perf: subj{np(str)} + {cp(że)}
przemyśleć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przenieść się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przenieść się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
przenieść się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przenieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przenieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przenieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przenieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przenieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przenikać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przenikać: _: : imperf: subj{cp(że)} + {prepnp(do,gen)}
przenikać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przenikać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przenikać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeniknąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przeniknąć: _: : perf: subj{cp(że)} + {prepnp(do,gen)}
przeniknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeniknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przeniknąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przenocować się: _: : perf: subj{np(str)} + {xp(locat)}
przenocować: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
przenocować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przenosić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przenosić się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
przenosić się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przenosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przenosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przenosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przenosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przenosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeobrazić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)}
przeobrazić się: _: : perf: subj{np(str)} + {advp(misc)}
przeobrazić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)}
przeobrazić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
przeobrażać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)}
przeobrażać się: _: : imperf: subj{np(str)} + {advp(misc)}
przeobrażać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)}
przeobrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
przeoczyć: _: : perf: subj{np(str)} + obj{cp(int)}
przeoczyć: _: : perf: subj{np(str)} + obj{cp(jak)}
przeoczyć: _: : perf: subj{np(str)} + obj{cp(że)}
przeoczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
przepadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepadać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przepadać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
przepadać: _: : imperf: subj{np(str)} + {prepncp(za,inst,żeby2)}
przepadać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przepadać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przepadać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,gdy); prepncp(za,inst,int); prepncp(za,inst,jak); prepncp(za,inst,kiedy); prepncp(za,inst,że)}
przepaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepaść: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przepaść: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
przepaść: _: : perf: subj{np(str)} + {prepnp(na,loc)}
przepaść: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przepchać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepchać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przepchnąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przepełniać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przepełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepełnić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
przepełnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przepędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przepędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przepędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przepędzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepisać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przepisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przepisywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przepisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przeplatać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
przeplatać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
przeplatać się: _: : imperf: subj{np(str)} + {np(inst)}
przeplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
przeplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przepleść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
przepleść się: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
przepleść się: _: : perf: subj{np(str)} + {np(inst)}
przepleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
przepleść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przepłynąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przepłynąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
przepłynąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przepłynąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przepłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przepłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepłynąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(przez,acc)}
przepływać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,loc)}
przepływać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
przepływać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przepływać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przepływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przepływać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepływać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(przez,acc)}
przepoławiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepoławiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
przepoławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przepołowić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepołowić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
przepołowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przepowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przepowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przepowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przepowiadać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przepowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przepowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przepowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
przepowiedzieć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przepracować się: _: : perf: subj{np(str)} + {np(inst)}
przepracować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepracowywać się: _: : imperf: subj{np(str)} + {np(inst)}
przepracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepraszać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przepraszać: _: : imperf: subj{np(str)} + {np(str)} + {or}
przepraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); cp(że); prepncp(za,acc,że)}
przeprosić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przeprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); cp(że); prepncp(za,acc,int); prepncp(za,acc,że)} + {or}
przepuszczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przepuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przepuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przepuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
przepuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przepuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przepuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepuścić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przepuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przepuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przepuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
przepuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przepuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przepuścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepychać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepychać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
przepychać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
przepychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepychać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przepytać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(po,loc)}
przepytać się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'okoliczność',atr)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
przepytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int)}
przepytywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(po,loc)}
przepytywać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'okoliczność',atr)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
przepytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int)}
przerabiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerabiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przerabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przeradzać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeradzać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przerastać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
przerastać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
przerastać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przerazić się: _: : perf: subj{np(str)} + {cp(int)}
przerazić się: _: : perf: subj{np(str)} + {cp(że)}
przerazić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przerazić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przerazić: _: : perf: subj{cp(gdy)} + {np(str)}
przerazić: _: : perf: subj{cp(int)} + {np(str)}
przerazić: _: : perf: subj{cp(jak)} + {np(str)}
przerazić: _: : perf: subj{cp(jeśli)} + {np(str)}
przerazić: _: : perf: subj{cp(kiedy)} + {np(str)}
przerazić: _: : perf: subj{cp(że)} + {np(str)}
przerazić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
przerazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przerażać się: _: : imperf: subj{np(str)} + {cp(int)}
przerażać się: _: : imperf: subj{np(str)} + {cp(że)}
przerażać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przerażać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przerażać: _: : imperf: subj{cp(gdy)} + {np(str)}
przerażać: _: : imperf: subj{cp(int)} + {np(str)}
przerażać: _: : imperf: subj{cp(jak)} + {np(str)}
przerażać: _: : imperf: subj{cp(jeśli)} + {np(str)}
przerażać: _: : imperf: subj{cp(kiedy)} + {np(str)}
przerażać: _: : imperf: subj{cp(że)} + {np(str)}
przerażać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
przerażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przerobić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerobić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przerobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przerodzić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przerodzić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przerosnąć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
przerosnąć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
przerosnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przerwać się: _: : perf: subj{np(str)}
przerwać: _: : perf: subj{np(str)} + {np(dat)} + {or}
przerwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przerysować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przerysować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przerysować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przerysowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przerysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przerysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przerywać się: _: : imperf: subj{np(str)}
przerywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przerywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przerznąć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerznąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przerznąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przerznąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przerzucać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przerzucać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przerzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(nad,inst)}
przerzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przerzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerzucić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przerzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(nad,inst)}
przerzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przerzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerzynać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przerzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przerzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przerżnąć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przesadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przesadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesadzać: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
przesadzać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
przesadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przesadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesadzić: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
przesadzić: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
przesądzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
przesądzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przesądzać: _: : imperf: subj{np(str)} + obj{cp(int)}
przesądzać: _: : imperf: subj{np(str)} + obj{cp(że)}
przesądzać: _: : imperf: subj{np(str)} + obj{cp(żeby)}
przesądzić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
przesądzić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przesądzić: _: : perf: subj{np(str)} + obj{cp(int)}
przesądzić: _: : perf: subj{np(str)} + obj{cp(że)}
przesądzić: _: : perf: subj{np(str)} + obj{cp(żeby)}
przesiać się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przesiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przesiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przesiadać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przesiadać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przesiadać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przesiadać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiadywać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
przesiadywać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {xp(dur)}
przesiadywać: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przesiadywać: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)} + {lexnp(inst,sg,'kamień',natr)}
przesiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesiąkać: _: : imperf: subj{np(str)} + {np(inst)}
przesiąknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesiąknąć: _: : perf: subj{np(str)} + {np(inst)}
przesiąść się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przesiąść się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przesiąść się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przesiąść się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiedzieć: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
przesiedzieć: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {xp(dur)}
przesiedzieć: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przesiewać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przesiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przesiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
przesłać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesłaniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
przesłonić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
przesłuchać: _: : perf: subj{np(str)} + obj{np(str)}
przesłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)}
przesłyszeć się: _: : perf: subj{np(str)} + {cp(że)}
przespać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przespać się: _: : perf: subj{np(str)} + {xp(locat)}
przespać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przestać: _: : perf: subj,controller{E} + controllee{infp(imperf)}
przestać: _: : perf: subj{np(str)} + obj{np(str)}
przestawać: _: : imperf: subj,controller{E} + controllee{infp(imperf)}
przestawać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przestawać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przestawiać się: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestawiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
przestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przestawić się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawić się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestawić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przestawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przestawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
przestawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przestawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przestawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przestąpić: _: : perf: subj{np(str)} + obj{np(str)}
przestąpić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestąpić: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przestępować: _: : imperf: subj{np(str)} + obj{np(str)}
przestępować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestępować: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przestępstwo: : : : {adjp(agr); prepnp(przeciw,dat); prepnp(z,inst); preplexnp(na,acc,sg,'szkoda',atr); preplexnp(na,loc,sg,'tło',atr); preplexnp(o,loc,sg,'charakter',atr)} + {possp}
przestępstwo: : : : {np(gen)} + {possp}
przestępstwo: : : : {possp} + {comprepnp(w stosunku do)}
przestępstwo: : : : {possp} + {prepnp(na,loc)}
przestępstwo: : : : {possp} + {prepnp(wobec,gen)}
przestraszyć się: _: : perf: subj{np(str)} + {cp(int)}
przestraszyć się: _: : perf: subj{np(str)} + {cp(że)}
przestraszyć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przestraszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przestraszyć: _: : perf: subj{cp(że)} + {np(str)}
przestraszyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
przestraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przestrzec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przestrzec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); cp(że); cp(żeby); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
przestrzec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {or}
przestrzegać: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
przestrzegać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przestrzegać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); cp(że); cp(żeby); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
przestrzegać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {or}
przestrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przestrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(perl)}
przestudiować: _: : perf: subj{np(str)} + {cp(int)}
przestudiować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
przesunąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesunąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przesunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesuwać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesuwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
przesuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesycać się: _: : imperf: subj{np(str)} + {np(inst)}
przesycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesycić się: _: : perf: subj{np(str)} + {np(inst)}
przesycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przesyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
przesyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesypiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przesypiać się: _: : imperf: subj{np(str)} + {xp(locat)}
przesypiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przeszczepiać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przeszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przeszczepić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przeszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przeszkadzać: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
przeszkadzać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
przeszkadzać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
przeszkadzać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przeszkadzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przeszklić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeszkodzić: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
przeszkodzić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
przeszkodzić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
przeszkodzić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przeszkodzić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przeszukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeszyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeszywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przeszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prześcigać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,żeby)} + {prepnp(z,inst)}
prześcigać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
prześcigać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
prześcigać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
prześcigać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
prześcigać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
prześcignąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
prześcignąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
prześcignąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
prześcignąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
prześladować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
prześladować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
prześledzić: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
prześledzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
prześlizgiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
prześlizgiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
prześlizgiwać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
prześlizgiwać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
prześlizgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
prześlizgnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
prześlizgnąć się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
prześlizgnąć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
prześliznąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
prześliznąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
prześliznąć się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
prześliznąć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przeświecać się: _: : imperf: subj{np(str)} + {np(inst)}
przeświecać się: _: : imperf: subj{np(str)} + {xp(locat)}
przeświecać się: _: : imperf: subj{np(str)} + {xp(perl)}
przeświecać: _: : imperf: subj{np(str)} + {np(inst)}
przeświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeświecać: _: : imperf: subj{np(str)} + {xp(abl)}
przeświecać: _: : imperf: subj{np(str)} + {xp(locat)}
przeświecać: _: : imperf: subj{np(str)} + {xp(perl)}
przeświecić się: _: : perf: subj{np(str)} + {np(inst)}
przeświecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeświecić: _: : perf: subj{np(str)} + {xp(dur)}
prześwietlać się: _: : imperf: subj{np(str)} + {np(dat)}
prześwietlać: _: : imperf: subj{np(str)} + {cp(int)}
prześwietlać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
prześwietlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prześwietlić się: _: : perf: subj{np(str)} + {np(dat)}
prześwietlić: _: : perf: subj{np(str)} + {cp(int)}
prześwietlić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
prześwietlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prześwitywać: _: : imperf: subj{np(str)} + {np(inst)}
prześwitywać: _: : imperf: subj{np(str)} + {xp(abl)}
prześwitywać: _: : imperf: subj{np(str)} + {xp(locat)}
prześwitywać: _: : imperf: subj{np(str)} + {xp(perl)}
przetaczać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przetaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeterminować się: _: : perf: subj{np(str)}
przetestować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przetestować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przetkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetkać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przetłumaczyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
przetłumaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepadjp(na,acc)} + {prepadjp(z,gen)}
przetłumaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetłumaczyć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)}
przetłumaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przetoczyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przetoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetransportować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetransportować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetransportować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przetrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetrącić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przetrwać: _: : perf: subj{np(str)} + obj{np(str)}
przetrząsać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetrząsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {xp(locat)}
przetrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
przetrzeć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
przetrzeć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
przetrzeć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przetrzeć się: _: : perf: {xp(locat)}
przetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przetrzymać: _: : perf: subj{np(str)} + {np(str)}
przetrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przetrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przetrzymywać: _: : imperf: subj{np(str)} + {np(str)}
przetrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przetrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przetwarzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetwarzać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetworzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetworzyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przewalać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przewalać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przewalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przewalić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przewalić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przewalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przeważać się: _: : imperf: subj{np(str)} + {xp(adl)}
przeważać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
przeważać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
przeważać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przeważać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
przeważać: _: : imperf: subj{np(str)} + {xp(locat)}
przeważyć się: _: : perf: subj{np(str)} + {xp(adl)}
przeważyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
przeważyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przeważyć: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
przewertować: _: : perf: subj{np(str)} + obj{np(str)}
przewiązać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
przewiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przewiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przewiązać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewiązywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
przewiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przewiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przewiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewidywać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
przewidywać: _: : imperf: subj{np(str)} + {or}
przewidzieć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
przewidzieć: _: : perf: subj{np(str)} + {or}
przewiercać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przewiercać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przewiercać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewiercać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przewiercać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przewiercić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przewiercić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przewiercić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewiercić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przewiercić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przewiesić się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przewiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przewiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przewieszać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przewieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przewieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przewietrzać się: _: : imperf: subj{np(str)} + {xp(locat)}
przewietrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewietrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przewietrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przewietrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przewietrzyć się: _: : perf: subj{np(str)} + {xp(locat)}
przewietrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewietrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przewietrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przewietrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przewieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przewieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(perl)}
przewijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przewijać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przewijać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewijać się: _: : imperf: subj{np(str)} + {xp(locat)}
przewijać się: _: : imperf: subj{np(str)} + {xp(perl)}
przewijać się: _: : imperf: subj{or} + {np(dat)} + {prepnp(przez,acc)}
przewijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przewijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przewijać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przewinąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przewinąć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewinąć się: _: : perf: subj{np(str)} + {xp(locat)}
przewinąć się: _: : perf: subj{np(str)} + {xp(perl)}
przewinąć się: _: : perf: subj{or} + {np(dat)} + {prepnp(przez,acc)}
przewinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przewinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przewinąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewlec się: _: : perf: subj{np(str)} + {xp(dur)}
przewlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przewlekać się: _: : imperf: subj{np(str)} + {xp(dur)}
przewlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przewodniczyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przewodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przewodzić: _: : imperf: subj{np(str)} + obj{np(str)}
przewodzić: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
przewozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przewozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(perl)}
przewozić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
przewozić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
przewracać się: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przewracać się: _: : imperf: {np(dat)} + {xp(locat)}
przewracać się: _: : imperf: subj{np(str)} + {np(dat)}
przewracać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przewracać się: _: : imperf: subj{np(str)} + {preplexnp(w,loc,_,'grób',natr)}
przewracać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewracać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przewracać: _: : imperf: subj{np(str)} + {np(inst)}
przewracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewracać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewrócić się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przewrócić się: _: : perf: subj{np(str)} + {np(dat)}
przewrócić się: _: : perf: subj{np(str)} + {preplexnp(w,loc,_,'grób',natr)}
przewrócić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewrócić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przewrócić: _: : perf: subj{np(str)} + {np(inst)}
przewrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewrócić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewyższać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przewyższać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
przewyższać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
przewyższyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przewyższyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
przewyższyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
przeziębiać się: _: : imperf: subj{np(str)}
przeziębiać: _: : imperf: subj{np(str)} + obj{np(str)}
przeziębić się: _: : perf: subj{np(str)}
przeziębić: _: : perf: subj{np(str)} + obj{np(str)}
przezimować: _: : perf: subj{np(str)} + {xp(locat)}
przeznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przeznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przeznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
przeznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
przeznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przeznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przeznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przeznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
przeznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
przeznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przezwać: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
przezwać: _: : perf: subj,controller{np(str)} + controllee{np(nom)} + {refl}
przezwać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
przezwać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
przezwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
przezwać: _: : perf: subj{np(str)} + {xp(mod)} + {refl}
przezwyciężać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
przezwyciężać: _: : imperf: subj{np(str)} + {refl}
przezwyciężyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
przezwyciężyć: _: : perf: subj{np(str)} + {refl}
przezywać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
przezywać: _: : imperf: subj,controller{np(str)} + controllee{np(nom)} + {refl}
przezywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
przezywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
przezywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(od,gen)}
przezywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
przezywać: _: : imperf: subj{np(str)} + {xp(mod)} + {refl}
przeżegnać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przeżegnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przeżreć się: _: : perf: subj{np(str)} + {np(inst)}
przeżreć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przeżreć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeżreć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przeżuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeżuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeżyć się: _: : perf: subj{np(str)}
przeżyć: _: : perf: subj,controller{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)} + controllee{xp(mod)}
przeżyć: _: : perf: subj{np(str)} + {cp(że)}
przeżyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)}
przeżyć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
przeżyć: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przeżywać się: _: : imperf: subj{np(str)}
przeżywać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(że)}
przeżywać: _: : imperf: subj,controller{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + controllee{xp(mod)}
przeżywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
przeżywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przeżywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przeżywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przeżywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przodować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(wśród,gen)}
przodować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
przybić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
przybić: _: : perf: subj{np(str)} + obj{lexnp(str,_,'piątka',natr)} + {prepnp(z,inst)}
przybić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przybić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przybić: _: : perf: subj{np(str)} + {xp(adl)}
przybiec: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
przybiec: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przybiec: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przybiegać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
przybiegać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przybiegać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przybierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przybierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przybierać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przybierać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przybijać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
przybijać: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'piątka',natr)} + {prepnp(z,inst)}
przybijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przybijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przybijać: _: : imperf: subj{np(str)} + {xp(adl)}
przyblednąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przyblednąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przyblednąć: _: : perf: subj{np(str)} + {xp(locat)}
przybliżać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżać się: _: : imperf: subj{np(str)} + {xp(adl)}
przybliżać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przybliżać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przybliżać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przybliżać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przybliżyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżyć się: _: : perf: subj{np(str)} + {xp(adl)}
przybliżyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przybliżyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przybliżyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przybliżyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przybrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przybrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przybrać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
przybrać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przybyć: _: : perf: {np(dat)} + {np(gen)}
przybyć: _: : perf: {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybyć: _: : perf: {np(gen)} + {xp(locat)}
przybyć: _: : perf: subj{np(str)} + {np(dat)}
przybyć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybyć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przybyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przybyć: _: : perf: subj{np(str)} + {xp(locat)}
przybywać: _: : imperf: {np(dat)} + {np(gen)}
przybywać: _: : imperf: {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybywać: _: : imperf: {np(gen)} + {xp(locat)}
przybywać: _: : imperf: subj{np(str)} + {np(dat)}
przybywać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przybywać: _: : imperf: subj{np(str)} + {xp(locat)}
przychodzić: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
przychodzić: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przychodzić: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przychodzić: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
przychodzić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
przychodzić: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przychodzić: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przychodzić: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przychodzić: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przychodzić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przychodzić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przychodzić: _: : imperf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przychodzić: _: : imperf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przychodzić: _: : imperf: subj{np(str)} + {np(dat)} + {fixed('w sukurs')}
przychodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przychodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przychodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
przychodzić: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'świat',natr)}
przychodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przychodzić: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
przychodzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przychodzić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przychodzić: _: : imperf: subj{np(str)} + {xp(adl)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
przychylać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przychylać się: _: : imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
przychylać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'niebo',atr)}
przychylać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przychylać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
przychylić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przychylić się: _: : perf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
przychylić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'niebo',atr)}
przychylić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przychylić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
przyciąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
przyciąć: _: : perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'drzemka',atr)}
przyciąć: _: : perf: subj{np(str)} + {lexnp(str,sg,'komar',natr)}
przyciąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przyciągać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen)}
przyciągać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {xp(adl)}
przyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
przyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {xp(abl)} + {xp(adl)}
przyciągnąć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen)}
przyciągnąć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {xp(adl)}
przyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
przyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {xp(abl)} + {xp(adl)}
przycichać: _: : imperf: {prepnp(o,loc); prepncp(o,loc,że)} + {xp(locat)}
przycichać: _: : imperf: subj{np(str)} + {xp(locat)}
przycichnąć: _: : perf: {prepnp(o,loc); prepncp(o,loc,że)} + {xp(locat)}
przycichnąć: _: : perf: subj{np(str)} + {xp(locat)}
przycinać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przycinać: _: : imperf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'drzemka',atr)}
przycinać: _: : imperf: subj{np(str)} + {lexnp(str,sg,'komar',natr)}
przycinać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przyciskać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przyciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przycisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przycisnąć: _: : perf: {np(str)}
przycisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przycisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przycupnąć: _: : perf: subj{np(str)} + {xp(locat)}
przyczepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
przyczepiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
przyczepiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
przyczepiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przyczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przyczepić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
przyczepić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
przyczepić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
przyczepić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przyczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przyczesać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przyczesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyczyniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
przyczyniać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
przyczynić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
przyczynić: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {np(inst)}
przydać się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
przydać się: _: : perf: subj{cp(żeby)} + {np(dat)}
przydać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przydać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
przydać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przydać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przydać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
przydać: _: : perf: subj{np(str)} + {cp(że)}
przydać: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)}
przydać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydarzać się: _: : imperf: subj,controller{infp(_)} + controllee{np(dat)} + {xp(temp)}
przydarzać się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {xp(locat)}
przydarzać się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {xp(temp)}
przydarzać się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(temp)}
przydarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przydarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
przydarzyć się: _: : perf: subj,controller{infp(_)} + controllee{np(dat)} + {xp(temp)}
przydarzyć się: _: : perf: subj{cp(żeby)} + {np(dat)} + {xp(locat)}
przydarzyć się: _: : perf: subj{cp(żeby)} + {np(dat)} + {xp(temp)}
przydarzyć się: _: : perf: subj{cp(że)} + {np(dat)} + {xp(temp)}
przydarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przydarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
przydawać się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
przydawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przydawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
przydawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przydawać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przydawać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
przydawać: _: : imperf: subj{np(str)} + {cp(że)}
przydawać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)}
przydawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
przydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
przydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przyganiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyganiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przyganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przygarbić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przygarbić się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
przygarbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przygasać: _: : imperf: subj{np(str)}
przygasnąć: _: : perf: subj{np(str)}
przygiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
przygiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przyginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
przyginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przyglądać się: _: : imperf: subj{np(str)} + {cp(jak)}
przyglądać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przyglądać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przygłuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przygłuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przygnać: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
przygnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
przygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
przygonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przygotować się: _: : perf: subj{np(str)} + {cp(że)}
przygotować się: _: : perf: subj{np(str)} + {cp(żeby)}
przygotować się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przygotować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
przygotować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przygotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przygotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
przygotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przygotowywać się: _: : imperf: subj{np(str)} + {cp(że)}
przygotowywać się: _: : imperf: subj{np(str)} + {cp(żeby)}
przygotowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przygotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
przygotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przygotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przygotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
przygotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przygrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przygrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przygryzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przygryzać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przygryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
przygryźć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przygryźć: _: : perf: subj{np(str)} + {np(dat)} + {or}
przygryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
przygważdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przygwoździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyjaźnić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przyjąć się: _: : perf: {infp(imperf)}
przyjąć się: _: : perf: subj{np(str)}
przyjąć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
przyjąć: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{prepadjp(za,acc)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{prepnp(za,acc)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
przyjąć: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(za,acc)}
przyjąć: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(za,inst)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {preplexnp(do,gen,sg,'wiadomość',atr)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(za,inst)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,_,'dach',batr)} + {fixed('z otwartymi ramionami')}
przyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi ramionami')}
przyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi rękami')}
przyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {xp(temp)}
przyjmować się: _: : imperf: {infp(imperf)}
przyjmować się: _: : imperf: subj{np(str)}
przyjmować: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjmować: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
przyjmować: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)}
przyjmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
przyjmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
przyjmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przyjmować: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
przyjmować: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(za,acc)}
przyjmować: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(za,inst)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {preplexnp(do,gen,sg,'wiadomości',atr)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {fixed('z otwartymi ramionami')}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {fixed('z otwartymi rękami')}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(za,inst)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,_,'dach',batr)} + {fixed('z otwartymi ramionami')}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi ramionami')}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi rękami')}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {xp(temp)}
przyjrzeć się: _: : perf: subj{np(str)} + {cp(jak)}
przyjrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyjrzeć się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przyjść: _: : perf: controller{np(dat)} + controllee{infp(_)}
przyjść: _: : perf: {np(dat)} + {prepncp(na,acc,że)}
przyjść: _: : perf: {np(dat)} + {prepnp(na,acc)}
przyjść: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyjść: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyjść: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
przyjść: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
przyjść: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyjść: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyjść: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyjść: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyjść: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyjść: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyjść: _: : perf: subj{lexnp(str,pl,'koza',natr)} + {fixed('do woza')}
przyjść: _: : perf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyjść: _: : perf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyjść: _: : perf: subj{np(str)} + {np(dat)} + {fixed('w sukurs')}
przyjść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przyjść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przyjść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
przyjść: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'świat',natr)}
przyjść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przyjść: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
przyjść: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przyjść: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przyjść: _: : perf: subj{np(str)} + {xp(adl)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
przykazać: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
przykazać: _: : perf: subj{np(str)} + {np(dat)} + {advp(pron)}
przykazać: _: : perf: subj{np(str)} + {np(dat)} + {or}
przykazać: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
przykazać: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przykazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przykleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przykleić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przykleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przykleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przyklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyklejać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przyklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przykład: : : : {np(gen); prepnp(na,acc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(na,acc,int); prepncp(na,acc,że)} + {possp}
przykład: : : : {possp} + {comprepnp(na rzecz)}
przykład: : : : {possp} + {comprepnp(na temat)}
przykład: : : : {possp} + {comprepnp(w kwestii)}
przykład: : : : {possp} + {comprepnp(w sprawie)}
przykład: : : : {possp} + {cp(jakoby)}
przykład: : : : {possp} + {or}
przykład: : : : {possp} + {prepnp(co do,gen)}
przykład: : : : {possp} + {prepnp(dla,gen)}
przykład: : : : {possp} + {prepnp(do,gen)}
przykład: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
przykład: : : : {possp} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(za,inst,że)}
przykład: : : : {possp} + {xp(abl)}
przykładać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przykładać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przykładać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'waga',atr)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przykładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przykładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przykładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przykładać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przykręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(na,acc)}
przykręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(na,acc)}
przykryć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przykryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przykuć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
przykuć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przykuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przykuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przykuwać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
przykuwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przykuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przykuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przylegać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyległy: : : : {prepnp(do,gen)} + {xp(abl)}
przylgnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyłapać się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
przyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
przyłączać się: _: : imperf: subj{np(str)} + {prepncp(do,gen,że)}
przyłączać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przyłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyłączyć się: _: : perf: subj{np(str)} + {prepncp(do,gen,że)}
przyłączyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przyłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyłożyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przyłożyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
przyłożyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
przyłożyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'waga',atr)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przyłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przymierać: _: : imperf: subj{np(str)} + {np(inst)}
przymierać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
przymierzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przymierzyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przymknąć się: _: : perf: subj{np(str)} + {np(dat)}
przymknąć: _: : perf: subj{np(str)} + obj{lexnp(str,_,'oko',natr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przymknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przymknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przymknąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przymocować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przymocować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przymocowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przymocowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przymrużyć: _: : perf: subj{np(str)} + obj{np(str)}
przymrużyć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(str,_,'oko',natr)}
przymrzeć: _: : perf: subj{np(str)} + {np(inst)}
przymrzeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
przymusić: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
przymusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
przymusić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
przymusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
przymusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przymuszać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
przymuszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
przymuszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
przymuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
przymuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przymykać się: _: : imperf: subj{np(str)} + {np(dat)}
przymykać: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'oko',natr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przymykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przymykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przymykać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przynależeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przynieść: _: : perf: {np(str)} + {xp(adl)}
przynieść: _: : perf: subj{lexnp(str,sg,'ślina',natr)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'język',natr)}
przynieść: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
przynieść: _: : perf: subj{np(str)} + {np(str)} + {xp(adl)}
przynieść: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przynieść: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'świat',natr)} + {preplexnp(z,inst,_,'siebie',natr)}
przynosić: _: : imperf: {np(str)} + {xp(adl)}
przynosić: _: : imperf: subj{lexnp(str,sg,'ślina',natr)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'język',natr)}
przynosić: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
przynosić: _: : imperf: subj{np(str)} + {np(str)} + {xp(adl)}
przynosić: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'świat',natr)} + {preplexnp(z,inst,_,'siebie',natr)}
przyozdabiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przyozdabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyozdabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
przyozdabiać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przyozdobić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przyozdobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyozdobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
przyozdobić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przypadać: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
przypadać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'udział',natr)}
przypadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przypadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
przypadać: _: : imperf: subj{np(str)} + {xp(temp)}
przypaść: _: : perf: subj,controllee{np(str)} + controller{infp(_)}
przypaść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'udział',natr)}
przypaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przypaść: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przypaść: _: : perf: subj{np(str)} + {xp(temp)}
przypatrywać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przypatrywać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
przypatrywać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przypatrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przypatrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
przypatrzeć się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przypatrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przypatrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
przypatrzyć się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przypiąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przypiąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przypiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przypiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przypiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przypieczętować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przypierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przypierać: _: : imperf: subj{cp(żeby)} + {np(str)}
przypierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przypinać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przypinać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przypinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przypinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przypinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przypisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,że)}
przypisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypisać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,że)}
przypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przypłacać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
przypłacić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
przypłynąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przypłynąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przypłynąć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przypływać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przypływać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przypływać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przypodobać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przypominać się: _: : imperf: {np(dat)} + {or}
przypominać się: _: : imperf: {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
przypominać się: _: : imperf: subj{cp(int); cp(że)} + {np(dat)}
przypominać się: _: : imperf: subj{cp(jak)} + {np(dat)}
przypominać się: _: : imperf: subj{cp(żeby2)} + {np(dat)}
przypominać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przypominać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
przypominać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przypominać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
przypominać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
przypominać: _: : imperf: subj{np(str)} + obj{np(str); prepnp(o,loc); cp(int); cp(jak); cp(że); cp(żeby); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
przypomnieć się: _: : perf: {np(dat)} + {or}
przypomnieć się: _: : perf: {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
przypomnieć się: _: : perf: subj{cp(int); cp(że)} + {np(dat)}
przypomnieć się: _: : perf: subj{cp(jak)} + {np(dat)}
przypomnieć się: _: : perf: subj{np(str)} + {np(dat)} + {or}
przypomnieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
przypomnieć: _: : perf: subj{np(str)} + obj{np(str); prepnp(o,loc); cp(int); cp(jak); cp(że); cp(żeby); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
przyporządkować: _: : perf: subj{np(str)} + {np(dat)} + {refl}
przyporządkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyporządkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyporządkować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przyporządkowywać: _: : imperf: subj{np(str)} + {np(dat)} + {refl}
przyporządkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyporządkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyporządkowywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przyprawiać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(o,acc)}
przyprawiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)} + {prepnp(o,acc)}
przyprawiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(o,acc)} + {refl}
przyprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyprawić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(o,acc)}
przyprawić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)} + {prepnp(o,acc)}
przyprawić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(o,acc)} + {refl}
przyprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyprawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyprószyć się: _: : perf: subj{np(str)} + {np(dat)}
przyprószyć: _: : perf: subj{E}
przyprószyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyprzeć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przyprzeć: _: : perf: subj{cp(żeby)} + {np(str)}
przyprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przypuszczać: _: : imperf: subj{np(str)} + {advp(pron)}
przypuszczać: _: : imperf: subj{np(str)} + {cp(int)}
przypuszczać: _: : imperf: subj{np(str)} + {cp(że)}
przypuszczać: _: : imperf: subj{np(str)} + {cp(żeby2)}
przypuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypuszczać: _: : imperf: subj{np(str)} + {or}
przypuścić: _: : perf: subj{np(str)} + {advp(pron)}
przypuścić: _: : perf: subj{np(str)} + {cp(int)}
przypuścić: _: : perf: subj{np(str)} + {cp(że)}
przypuścić: _: : perf: subj{np(str)} + {cp(żeby2)}
przypuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypuścić: _: : perf: subj{np(str)} + {or}
przyrównać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyrównać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przyrównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyrównywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przyrządzać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przyrządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przyrządzić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przyrządzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przyrzec: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
przyrzec: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyrzec: _: : perf: subj{np(str)} + {np(dat)} + {or}
przyrzec: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przyrzekać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
przyrzekać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyrzekać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przyrzekać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przysądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przysądzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysądzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przysiadać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przysiadać: _: : imperf: subj{np(str)} + {lexnp(gen,_,'fałd',natr)}
przysiadać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przysiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przysiadać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przysiadać: _: : imperf: subj{np(str)} + {xp(adl)}
przysiąc się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
przysiąc: _: : perf: subj,controller{np(str)} + obj,controllee{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przysiąść się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przysiąść: _: : perf: subj{np(str)} + {lexnp(gen,_,'fałd',natr)}
przysiąść: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przysiąść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przysiąść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przysiąść: _: : perf: subj{np(str)} + {xp(adl)}
przysięgać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
przysięgać: _: : imperf: subj,controller{np(str)} + obj,controllee{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przysięgnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
przysięgnąć: _: : perf: subj,controller{np(str)} + obj,controllee{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przysłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
przysłaniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przysłaniać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przysłaniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
przysłonić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przysłonić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przysłonić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
przysłuchiwać się: _: : imperf: subj{np(str)} + {cp(int)}
przysłuchiwać się: _: : imperf: subj{np(str)} + {cp(jak)}
przysłuchiwać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przysługiwać: _: : imperf: subj{np(str)} + {np(dat)}
przysłużyć się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
przysłużyć się: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
przysłużyć się: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
przyspieszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
przyspieszać: _: : imperf: subj{np(str)} + {np(gen)}
przyspieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyspieszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
przyspieszyć: _: : perf: subj{np(str)} + {np(gen)}
przyspieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przystać: _: : perf: {np(dat)} + {advp(pron)}
przystać: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
przystać: _: : perf: subj{cp(żeby)} + {np(dat)}
przystać: _: : perf: subj{np(str)} + {np(dat)}
przystać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przystać: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przystanąć: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
przystanąć: _: : perf: subj{np(str)} + {xp(locat)}
przystawać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
przystawać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przystawać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
przystawać: _: : imperf: subj{np(str)} + {xp(locat)}
przystawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przystawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przystawić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przystawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przystąpić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przystępować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przystosować się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przystosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przystosowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przystosowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przystrajać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przystrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przystrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
przystrajać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przystroić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przystroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przystroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
przystroić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przystrzyc się: _: : perf: subj{np(str)} + {xp(locat)}
przystrzyc: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przystrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przystrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
przystrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przystrzygać się: _: : imperf: subj{np(str)} + {xp(locat)}
przystrzygać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przystrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przystrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
przystrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyswajać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przyswajać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyswajać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przyswoić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyswoić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyswoić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przyśnić się: _: : perf: {np(dat)}
przyśnić się: _: : perf: subj{cp(int)} + {np(dat)}
przyśnić się: _: : perf: subj{cp(jak)} + {np(dat)}
przyśnić się: _: : perf: subj{cp(żeby)} + {np(dat)}
przyśnić się: _: : perf: subj{cp(że)} + {np(dat)}
przyśnić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby)} + {np(dat)}
przyśpieszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
przyśpieszać: _: : imperf: subj{np(str)} + {np(gen)}
przyśpieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyśpieszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
przyśpieszyć: _: : perf: subj{np(str)} + {np(gen)}
przyśpieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyświecać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
przyświecać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przytaczać się: _: : imperf: subj{np(str)} + {xp(adl)}
przytaczać: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(jako,str)}
przytaczać: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)}
przytaczać: _: : imperf: subj{np(str)} + obj{cp(int)}
przytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
przytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przytakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
przytakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
przytaknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
przytaknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
przytknąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przytknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przytknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
przytknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przytłaczać: _: : imperf: subj{cp(int)} + {np(str)}
przytłaczać: _: : imperf: subj{cp(jak)} + {np(str)}
przytłaczać: _: : imperf: subj{cp(że)} + {np(str)}
przytłaczać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(str)}
przytłaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przytłaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytłoczyć: _: : perf: subj{cp(int)} + {np(str)}
przytłoczyć: _: : perf: subj{cp(jak)} + {np(str)}
przytłoczyć: _: : perf: subj{cp(że)} + {np(str)}
przytłoczyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(str)}
przytłoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przytłoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytłumiać: _: : imperf: subj{np(str)} + obj{np(str)}
przytoczyć się: _: : perf: subj{np(str)} + {xp(adl)}
przytoczyć: _: : perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(jako,str)}
przytoczyć: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)}
przytoczyć: _: : perf: subj{np(str)} + obj{cp(int)}
przytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
przytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przytrafiać się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
przytrafiać się: _: : imperf: subj{cp(że)} + {np(dat)}
przytrafiać się: _: : imperf: subj{np(str)} + {np(dat)}
przytrafić się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
przytrafić się: _: : perf: subj{cp(że)} + {np(dat)}
przytrafić się: _: : perf: subj{np(str)} + {np(dat)}
przytrzymać się: _: : perf: subj{np(str)} + {np(gen)}
przytrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {xp(locat)}
przytrzymywać się: _: : imperf: subj{np(str)} + {np(gen)}
przytrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {xp(locat)}
przytulać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przytulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytulać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
przytulać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {refl}
przytulić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przytulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
przytulić: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {refl}
przytwierdzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przytwierdzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przytwierdzać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
przytwierdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przytwierdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przytwierdzać: _: : imperf: subj{np(str)} + {or}
przytwierdzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przytwierdzić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przytwierdzić: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
przytwierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przytwierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przytwierdzić: _: : perf: subj{np(str)} + {or}
przytykać się: _: : imperf: subj{np(str)} + {np(dat)}
przytykać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przytykać: _: : imperf: {np(str)}
przytykać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przytykać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przytykać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyuczać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyuczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyuczyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywędrować: _: : perf: subj{np(str)} + {xp(adl)} + {xp(adl)} + {xp(perl)}
przywiązać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywiązać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {refl}
przywiązać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)}
przywiązywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywiązywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {refl}
przywiązywać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)}
przywierać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przywiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przywiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przywieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przywieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przywieść: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że)}
przywieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
przywitać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przywitać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przywitać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przywłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
przywłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
przywodzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że)}
przywodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywołać: _: : perf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(jako,str)}
przywołać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przywołać: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)}
przywołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przywołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przywołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywoływać: _: : imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(jako,str)}
przywoływać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przywoływać: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)}
przywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
przywracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przywracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przywracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przywracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przywrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przywrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przywrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przywrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przywrzeć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przywyknąć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
przywyknąć: _: : perf: subj{np(str)} + {cp(że)}
przywyknąć: _: : perf: subj{np(str)} + {cp(żeby)}
przywyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyznać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyznać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby2)}
przyznać się: _: : perf: subj{np(str)} + {or}
przyznać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyznać: _: : perf: subj{np(str)} + {or}
przyznawać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przyznawać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepncp(do,gen,int)}
przyznawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że)}
przyznawać się: _: : imperf: subj{np(str)} + {or}
przyznawać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyznawać: _: : imperf: subj{np(str)} + {or}
przyzwyczaić się: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczaić się: _: : perf: subj{np(str)} + {cp(że)}
przyzwyczaić się: _: : perf: subj{np(str)} + {cp(żeby)}
przyzwyczaić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyzwyczaić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczaić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
przyzwyczaić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przyzwyczaić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyzwyczajać się: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczajać się: _: : imperf: subj{np(str)} + {cp(że)}
przyzwyczajać się: _: : imperf: subj{np(str)} + {cp(żeby)}
przyzwyczajać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyzwyczajać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczajać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
przyzwyczajać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przyzwyczajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pstrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
pstrzyć się: _: : imperf: subj{np(str)} + {np(inst)}
pstrzyć się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pstrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
psuć się: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
psuć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
psuć: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
psuć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
psyknąć: _: : perf: subj{np(str)} + {xp(locat)}
publikować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
puchnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
puchnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pukać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pukać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pukać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pukać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(z,inst)}
pukać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pukać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pukać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
pulsować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
punktować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
punktować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
punktować: _: : imperf: subj{np(str)} + {xp(mod)}
pustoszeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pustoszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
puszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
puszczać się: _: : imperf: subj{np(str)} + {np(gen)}
puszczać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
puszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
puszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
puszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
puszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pysznić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
pysznić się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
pysznić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
pysznić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
pytać się: _: : imperf: subj{np(str)} + {np(gen)} + {or}
pytać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
pytać: _: : imperf: subj{np(str)} + obj{np(gen)} + {or}
pytać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
pytać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
pytać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
pytać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rabować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
rabować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rachować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rachować: _: : imperf: subj{np(str)} + {cp(int)}
rachować: _: : imperf: subj{np(str)} + {cp(że)}
rachować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rachować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rachować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rachować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
raczyć się: _: : imperf: subj{np(str)} + {np(inst)}
raczyć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
raczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
radość: : : : {np(gen)} + {possp}
radość: : : : {possp} + {cp(że)}
radość: : : : {possp} + {prepnp(po,loc)}
radość: : : : {possp} + {prepnp(z,gen); comprepnp(z powodu); prepncp(z,gen,int); prepncp(z,gen,że)}
radować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
radować się: _: : imperf: subj{np(str)} + {cp(że)}
radować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
radować się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
radować się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
radować: _: : imperf: subj{cp(gdy)} + {np(str)}
radować: _: : imperf: subj{cp(int)} + {np(str)}
radować: _: : imperf: subj{cp(jak)} + {np(str)}
radować: _: : imperf: subj{cp(jeśli)} + {np(str)}
radować: _: : imperf: subj{cp(kiedy)} + {np(str)}
radować: _: : imperf: subj{cp(że)} + {np(str)}
radować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
radować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(str,int)} + {np(str)}
radzić się: _: : imperf: subj{np(str)} + {np(gen)} + {cp(int)}
radzić się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
radzić się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
radzić: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
radzić: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{cp(żeby); infp(_)}
radzić: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
radzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
radzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
radzić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
radzić: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
radzić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)}
radzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
rajcować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rajcować: _: : imperf: subj{cp(int)} + {np(str)}
rajcować: _: : imperf: subj{cp(jak)} + {np(str)}
rajcować: _: : imperf: subj{cp(że)} + {np(str)}
rajcować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(str)}
rajcować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
rajcować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
ranić się: _: : _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ranić się: _: : _: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
ranić: _: : _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
ranić: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ranić: _: : imperf: subj{cp(gdy)} + {np(str)}
ranić: _: : imperf: subj{cp(jak)} + {np(str)}
ranić: _: : imperf: subj{cp(jeśli)} + {np(str)}
ranić: _: : imperf: subj{cp(kiedy)} + {np(str)}
ranić: _: : imperf: subj{cp(że)} + {np(str)}
ranić: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
ranić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,acc)}
raportować: _: : imperf: subj{np(str)} + {cp(int)} + {xp(adl)}
raportować: _: : imperf: subj{np(str)} + {cp(że)} + {xp(adl)}
raportować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
raportować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
raportować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
raportować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
raportować: _: : imperf: subj{np(str)} + obj{np(str)}
raportować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
raportować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
raportować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
raportować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
raportować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(adl)}
raportować: _: : imperf: subj{np(str)} + {xp(adl)} + {or}
ratować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
ratować się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
ratować się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
ratować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
ratować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ratować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(przed,inst)}
ratować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ratować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ratyfikować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
razić: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
razić: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
razić: _: : imperf: subj{cp(gdy)} + {np(str)}
razić: _: : imperf: subj{cp(jak)} + {np(str)}
razić: _: : imperf: subj{cp(jeśli)} + {np(str)}
razić: _: : imperf: subj{cp(kiedy)} + {np(str)}
razić: _: : imperf: subj{cp(że)} + {np(str)}
razić: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
razić: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
razić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rąbnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rąbnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rąbnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
rąbnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rąbnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
rąbnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
rąbnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rąbnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rąbnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rąbnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rąbnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rąbnąć: _: : perf: subj{np(str)} + {or}
rąbnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rąbnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rąbnąć: _: : perf: subj{np(str)} + {xp(adl)}
rąbnąć: _: : perf: subj{np(str)} + {xp(locat)}
rąbnąć: _: : perf: {xp(locat)}
reagować: _: : imperf: subj{np(str)} + controller{prepnp(na,acc); prepncp(na,acc,jak); prepncp(na,acc,że)} + controllee{xp(mod)}
reagować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,jak); prepncp(na,acc,że)}
reagować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int)}
reagować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
reaktywować się: _: : _: subj{np(str)}
reaktywować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
realizować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
realizować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
realizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
reanimować się: _: : _: subj{np(str)} + {np(inst)}
reanimować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
reasumować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
reasumować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rechotać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
rechotać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
rechotać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
rechotać: _: : imperf: subj{np(str)}
rechotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
rechotać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
rechotać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
recytować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
recytować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
recytować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
recytować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
redagować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
redukować się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
redukować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
referować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
referować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
referować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
referować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
referować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
reformować się: _: : imperf: subj{np(str)}
reformować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
refundować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
regenerować się: _: : imperf: subj{np(str)} + {np(dat)}
regenerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
regulować się: _: : imperf: subj{np(str)}
regulować: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'rachunek',atr)} + {prepnp(z,inst)}
regulować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rehabilitować się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rehabilitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rehabilitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
rejestrować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
rejestrować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rejestrować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rejestrować się: _: : imperf: subj{np(str)} + {xp(locat)}
rejestrować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
rejestrować: _: : imperf: subj{np(str)} + obj{cp(int)}
rejestrować: _: : imperf: subj{np(str)} + obj{cp(jak)}
rejestrować: _: : imperf: subj{np(str)} + obj{cp(że)}
rejestrować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
rejestrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rejestrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rejestrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rejestrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rejestrować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
reklamować: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
reklamować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
reklamować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
reklamować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
reklamować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
reklamować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
reklamować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
reklamować: _: : imperf: subj{np(str)} + {or} + {refl}
reklamować: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
reklamować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
reklamować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
rekomendować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
rekomendować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
rekomendować: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
rekomendować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rekomendować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
rekomendować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
rekomendować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
rekomendować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
rekomendować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rekomendować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rekomendować: _: : imperf: subj{np(str)} + {or}
rekomendować: _: : imperf: subj{np(str)} + {or} + {refl}
rekompensować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(dat)}
rekompensować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
rekonstruować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rekonstruować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rekrutować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rekrutować się: _: : imperf: subj{np(str)} + {prepnp(spośród,gen)}
rekrutować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rekrutować się: _: : imperf: subj{np(str)} + {xp(abl)}
rekrutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(spośród,gen)}
rekrutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
rekwirować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
relacja: : : : {np(gen)} + {prepnp(do,gen); prepnp(wobec,gen); prepnp(względem,gen); comprepnp(w stosunku do)}
relacja: : : : {np(gen)} + {prepnp(z,inst)}
relacja: : : : {np(nom)} + {np(nom)}
relacja: : : : {possp} + {comprepnp(na temat)} + {xp(abl)}
relacja: : : : {possp} + {comprepnp(w sprawie)} + {xp(abl)}
relacja: : : : {possp} + {comprepnp(w stosunku do)}
relacja: : : : {possp} + {cp(int); cp(że)} + {xp(abl)}
relacja: : : : {possp} + {cp(jakoby)} + {xp(abl)}
relacja: : : : {possp} + {prepnp(co do,gen)} + {xp(adl)}
relacja: : : : {possp} + {prepnp(do,gen)}
relacja: : : : {possp} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)} + {xp(abl)}
relacja: : : : {possp} + {prepnp(wobec,gen)}
relacja: : : : {possp} + {prepnp(względem,gen)}
relacja: : : : {possp} + {prepnp(z,inst)}
relacja: : : : {possp} + {xp(abl)} + {or}
relacja: : : : {prepnp(między,inst)}
relacja: : : : {prepnp(wśród,gen)}
relacjonować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
relacjonować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
relacjonować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
relacjonować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
relacjonować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
relaksować się: _: : imperf: subj{np(str)} + {advp(misc)}
relaksować się: _: : imperf: subj{np(str)} + {np(inst)}
relaksować: _: : imperf: subj{np(str)} + {np(str)}
remontować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
remontować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
reperować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
repetować: _: : imperf: subj{np(str)} + obj{np(str)}
replikować się: _: : imperf: subj{np(str)}
replikować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
replikować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
replikować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
represjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
reprezentować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
respektować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
restaurować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
restrukturyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
restrukturyzować: _: : imperf: subj{np(str)} + {refl}
rewanżować się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rewidować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rezerwować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rezerwować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
rezerwować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rezonować: _: : imperf: subj{E} + {prepnp(od,gen)}
rezonować: _: : imperf: subj{np(str)} + {cp(że)}
rezonować: _: : imperf: subj{np(str)} + {np(inst)}
rezonować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
rezonować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rezonować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rezygnować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
reżyserować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
reżyserować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
ręczyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {cp(że)}
ręczyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
ripostować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
ripostować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
ripostować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
ripostować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
ripostować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
robić się: _: : imperf: {np(dat)} + {advp(misc)}
robić się: _: : imperf: {prepnp(z,inst)} + {advp(misc)}
robić się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
robić się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
robić się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)}
robić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
robić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
robić się: _: : imperf: {xp(locat)} + {advp(misc)}
robić: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
robić: _: : imperf: subj{np(str)} + {cp(że)} + {advp(misc)}
robić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
robić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {advp(misc)}
robić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
robić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
robić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
robić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
robić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
robić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
robić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
robić: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
robić: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
robić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {nonch} + {lexnp(dat,_,'siebie',natr)}
rodzić się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
rodzić się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
rodzić się: _: : imperf: subj{np(str)} + {np(dat)}
rodzić się: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'kamień',natr)}
rodzić się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
rodzić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rodzić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
rodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
roić się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
roić się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
roić się: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
roić się: _: : imperf: subj{E} + {prepnp(od,gen)} + {xp(locat)}
roić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(po,loc,_,'głowa',natr)}
roić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
roić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
roić: _: : imperf: subj{np(str)} + {cp(że)}
roić: _: : imperf: subj{np(str)} + {np(str)}
roić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby)}
rola: : : : {adjp(agr)} + {possp} + {prepnp(w,loc)} + {comp(jako)}
rola: : : : {np(gen)} + {adjp(agr)} + {possp} + {prepnp(u,gen)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
rola: : : : {np(gen)} + {adjp(agr)} + {prepnp(dla,gen)} + {prepnp(u,gen)} + {prepnp(w,loc)}
romansować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rosnąć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
rosnąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rosnąć: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
roszczenie: : : : {possp} + {comprepnp(w kwestii)}
roszczenie: : : : {possp} + {comprepnp(w sprawie)}
roszczenie: : : : {possp} + {comprepnp(w stosunku do)}
roszczenie: : : : {possp} + {cp(że)}
roszczenie: : : : {possp} + {cp(żeby)}
roszczenie: : : : {possp} + {preplexnp(z,gen,sg,'tytuł',atr)}
roszczenie: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,żeby)}
roszczenie: : : : {possp} + {prepnp(do,gen); prepnp(o,acc); prepncp(do,gen,żeby); prepncp(o,acc,żeby)}
roszczenie: : : : {possp} + {prepnp(między,inst); prepnp(przeciw,dat); prepnp(względem,gen)}
roszczenie: : : : {possp} + {prepnp(od,gen)}
roszczenie: : : : {possp} + {prepnp(wobec,gen)}
roszczenie: : : : {possp} + {prepnp(za,acc)}
roszczenie: : : : {possp} + {prepnp(z,gen)}
rościć: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
rozbawić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozbawić: _: : perf: subj{cp(gdy)} + {np(str)}
rozbawić: _: : perf: subj{cp(int)} + {np(str)}
rozbawić: _: : perf: subj{cp(jak)} + {np(str)}
rozbawić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozbawić: _: : perf: subj{cp(że)} + {np(str)}
rozbawić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozbawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozbestwiać się: _: : imperf: subj{np(str)}
rozbestwiać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozbestwiać: _: : imperf: subj{cp(int)} + {np(str)}
rozbestwiać: _: : imperf: subj{cp(jak)} + {np(str)}
rozbestwiać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozbestwiać: _: : imperf: subj{cp(że)} + {np(str)}
rozbestwiać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozbestwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozbestwić się: _: : perf: subj{np(str)}
rozbestwić: _: : perf: subj{cp(gdy)} + {np(str)}
rozbestwić: _: : perf: subj{cp(int)} + {np(str)}
rozbestwić: _: : perf: subj{cp(jak)} + {np(str)}
rozbestwić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozbestwić: _: : perf: subj{cp(że)} + {np(str)}
rozbestwić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozbestwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozbić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
rozbić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
rozbić się: _: : perf: subj{np(str)} + {np(inst)}
rozbić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozbić się: _: : perf: subj{np(str)} + {xp(locat)}
rozbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbiec się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
rozbiec się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
rozbiec się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozbiec się: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
rozbiegać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
rozbiegać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
rozbiegać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozbiegać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
rozbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)}
rozbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozbierać: _: : imperf: subj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)} + {refl}
rozbierać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozbijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
rozbijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
rozbijać się: _: : imperf: subj{np(str)} + {np(inst)}
rozbijać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozbijać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbłyskać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozbłyskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozbłyskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozbłyskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozbłysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
rozbłysnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
rozboleć: _: : perf: {np(str)} + {comprepnp(z powodu)} + {xp(locat)}
rozboleć: _: : perf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
rozboleć: _: : perf: {np(str)} + {prepnp(z,gen)} + {xp(locat)}
rozboleć: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(z powodu)}
rozboleć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
rozboleć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
rozbrajać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozbrajać: _: : imperf: subj{cp(int)} + {np(str)}
rozbrajać: _: : imperf: subj{cp(jak)} + {np(str)}
rozbrajać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozbrajać: _: : imperf: subj{cp(że)} + {np(str)}
rozbrajać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozbrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozbrajać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozbroić: _: : perf: subj{cp(gdy)} + {np(str)}
rozbroić: _: : perf: subj{cp(int)} + {np(str)}
rozbroić: _: : perf: subj{cp(jak)} + {np(str)}
rozbroić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozbroić: _: : perf: subj{cp(że)} + {np(str)}
rozbroić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozbroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozbroić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozbrykać się: _: : perf: subj{np(str)}
rozbudować się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
rozbudować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozbudować się: _: : perf: subj{np(str)} + {xp(adl)}
rozbudować się: _: : perf: subj{np(str)} + {xp(locat)}
rozbudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozbudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozbudować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozbudować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozbudowywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
rozbudowywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozbudowywać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozbudowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozbudzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rozbudzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozbudzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rozbudzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
rozbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
rozbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
rozbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rozbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
rozbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
rozbudzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
rozbudzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozbudzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozbudzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
rozbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
rozbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
rozbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rozbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
rozbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
rozchichotać się: _: : perf: subj{np(str)}
rozchmurzać się: _: : imperf: subj{E}
rozchmurzać się: _: : imperf: subj{np(str)} + {np(dat)}
rozchmurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozchmurzyć się: _: : perf: subj{E}
rozchmurzyć się: _: : perf: subj{np(str)} + {np(dat)}
rozchmurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozchodzić się: _: : perf: subj{np(str)} + {np(dat)}
rozchodzić się: _: : imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozchodzić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
rozchodzić się: _: : imperf: subj{cp(że)} + {xp(locat)}
rozchodzić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
rozchodzić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozchodzić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozchodzić się: _: : imperf: subj{np(str)} + {xp(locat)}
rozchodzić: _: : perf: subj{np(str)} + obj{np(str)}
rozchorować się: _: : perf: subj{np(str)} + {advp(misc)}
rozchorować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
rozchorować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
rozchylać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
rozchylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
rozchylić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
rozchylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
rozciąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
rozciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
rozciągać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozciągać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozciągać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozciągać się: _: : imperf: subj{np(str)} + {xp(abl)}
rozciągać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rozciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozciągnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozciągnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozciągnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozciągnąć się: _: : perf: subj{np(str)} + {xp(abl)}
rozciągnąć się: _: : perf: subj{np(str)} + {xp(locat)}
rozciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rozciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozcieńczać się: _: : imperf: subj{np(str)}
rozcieńczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozcieńczyć się: _: : perf: subj{np(str)}
rozcieńczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozcierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozcierać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
rozcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
rozcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
rozczarować się: _: : perf: subj{np(str)} + {comprepnp(co do)}
rozczarować się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
rozczarować się: _: : perf: subj{np(str)} + {cp(int)}
rozczarować się: _: : perf: subj{np(str)} + {cp(że)}
rozczarować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozczarować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
rozczarować: _: : perf: subj{cp(gdy)} + {np(str)}
rozczarować: _: : perf: subj{cp(int)} + {np(str)}
rozczarować: _: : perf: subj{cp(jak)} + {np(str)}
rozczarować: _: : perf: subj{cp(jeśli)} + {np(str)}
rozczarować: _: : perf: subj{cp(kiedy)} + {np(str)}
rozczarować: _: : perf: subj{cp(że)} + {np(str)}
rozczarować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozczarować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozczarować: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(co do)}
rozczarować: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
rozczarowywać się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
rozczarowywać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
rozczarowywać się: _: : imperf: subj{np(str)} + {cp(int)}
rozczarowywać się: _: : imperf: subj{np(str)} + {cp(że)}
rozczarowywać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozczarowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rozczarowywać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozczarowywać: _: : imperf: subj{cp(int)} + {np(str)}
rozczarowywać: _: : imperf: subj{cp(jak)} + {np(str)}
rozczarowywać: _: : imperf: subj{cp(jeśli)} + {np(str)}
rozczarowywać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozczarowywać: _: : imperf: subj{cp(że)} + {np(str)}
rozczarowywać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozczarowywać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozczarowywać: _: : imperf: subj{np(str)} + {np(str)} + {comprepnp(co do)}
rozczarowywać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
rozdać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ręka',atr)}
rozdać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ręka',atr)}
rozdawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdąć się: _: : perf: subj{np(str)} + {np(dat)}
rozdąć: _: : perf: {np(str)}
rozdąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozdeptać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozdeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozdeptać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozdeptywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozdeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozdeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozdmuchać się: _: : perf: subj{E}
rozdmuchać się: _: : perf: subj{np(str)} + {np(dat)}
rozdmuchać: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(inst)}
rozdmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozdmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rozdmuchiwać się: _: : imperf: subj{E}
rozdmuchiwać się: _: : imperf: subj{np(str)} + {np(dat)}
rozdmuchiwać: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(inst)}
rozdmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozdmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rozdrabniać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozdrabniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozdrabniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozdrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozdrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(między,acc)}
rozdrapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozdrapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(między,acc)}
rozdrobnić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozdrobnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozdrobnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozdymać się: _: : imperf: subj{np(str)} + {np(dat)}
rozdymać: _: : imperf: {np(str)}
rozdymać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozdysponować: _: : perf: subj{np(str)} + {np(inst)}
rozdysponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdysponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozdysponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdysponowywać: _: : imperf: subj{np(str)} + {np(inst)}
rozdysponowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdysponowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozdysponowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdzielać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozdzielać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozdzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozdzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
rozdzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rozdzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozdzielić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozdzielić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
rozdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rozdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozdzierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozdzierać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozdzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozdzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozdzierać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {cp(że)}
rozdzierać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {or}
rozdzierać: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'szata',natr)} + {cp(że)}
rozdzierać: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'szata',natr)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozdziewiczyć: _: : perf: subj{np(str)} + obj{np(str)}
rozebrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozebrać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)}
rozebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozebrać: _: : perf: subj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)} + {refl}
rozebrać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozedrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozedrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozedrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozedrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozedrzeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {cp(że)}
rozedrzeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {or}
rozedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozegrać się: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
rozegrać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
rozegrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)} + {xp(temp)}
rozejrzeć się: _: : perf: subj{np(str)} + {cp(int)} + {xp(adl)}
rozejrzeć się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozejrzeć się: _: : perf: subj{np(str)} + {prepnp(po,loc); xp(locat)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
rozejrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozejść się: _: : perf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozejść się: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
rozejść się: _: : perf: subj{cp(że)} + {xp(locat)}
rozejść się: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
rozejść się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozejść się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozejść się: _: : perf: subj{np(str)} + {xp(locat)}
rozepchnąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
rozepchnąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozeprzeć się: _: : perf: subj{np(str)} + {xp(locat)}
rozeprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozerwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozerwać: _: : perf: {np(dat)} + {np(str)} + {prepnp(na,acc)}
rozerwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozesłać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozesłać się: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
rozesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rozesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
rozesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
rozesłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
rozesłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
roześmiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {cp(że)}
roześmiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
roześmiać się: _: : perf: subj{np(str)} + {np(inst)}
roześmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozetrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozetrzeć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
rozetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozewrzeć się: _: : perf: subj{np(str)} + {np(dat)}
rozewrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozewrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozeznać się: _: : perf: subj{np(str)} + {comprepnp(co do)}
rozeznać się: _: : perf: subj{np(str)} + {cp(int)}
rozeznać się: _: : perf: subj{np(str)} + {cp(że)}
rozeznać się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
rozeznać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozeznać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozeznać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
rozeznawać się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
rozeznawać się: _: : imperf: subj{np(str)} + {cp(int)}
rozeznawać się: _: : imperf: subj{np(str)} + {cp(że)}
rozeznawać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
rozeznawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozeznawać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozeznawać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
rozformować się: _: : perf: subj{np(str)} + {xp(locat)}
rozformować: _: : perf: subj{np(str)} + obj{np(str)}
rozgarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
rozgarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
rozglądać się: _: : imperf: subj{np(str)} + {cp(int)} + {xp(adl)}
rozglądać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozglądać się: _: : imperf: subj{np(str)} + {prepnp(po,loc); xp(locat)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
rozglądać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozgniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozgniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozgniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozgniewać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rozgniewać: _: : perf: subj{cp(że); ncp(str,że)} + {np(str)}
rozgniewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozgonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rozgonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
rozgorączkować się: _: : perf: subj{np(str)} + {cp(że)}
rozgorączkować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozgorączkować się: _: : perf: subj{np(str)} + {or}
rozgorączkować: _: : perf: subj{cp(gdy)} + {np(str)}
rozgorączkować: _: : perf: subj{cp(int)} + {np(str)}
rozgorączkować: _: : perf: subj{cp(jak)} + {np(str)}
rozgorączkować: _: : perf: subj{cp(kiedy)} + {np(str)}
rozgorączkować: _: : perf: subj{cp(że)} + {np(str)}
rozgorączkować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozgorączkować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozgoryczyć się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
rozgoryczyć: _: : perf: subj{np(str)} + {np(str)}
rozgorzeć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
rozgorzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozgorzeć: _: : perf: subj{np(str)} + {xp(locat)}
rozgromić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozgromić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozgrywać się: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
rozgrywać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
rozgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)} + {xp(temp)}
rozgrzać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rozgrzać się: _: : perf: subj{np(str)} + {np(inst)}
rozgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozgrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozgrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozgrzewać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rozgrzewać się: _: : imperf: subj{np(str)} + {np(inst)}
rozgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozjaśniać się: _: : imperf: {np(dat)} + {xp(locat)}
rozjaśniać się: _: : imperf: subj{np(str)} + {np(dat)}
rozjaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjaśnić się: _: : perf: {np(dat)} + {xp(locat)}
rozjaśnić się: _: : perf: subj{np(str)} + {np(dat)}
rozjaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjechać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
rozjechać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(locat)}
rozjechać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
rozjechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjeździć się: _: : perf: subj{np(str)}
rozjeździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjeżdżać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
rozjeżdżać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(locat)}
rozjeżdżać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
rozjeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozkaz: : : : {np(gen)} + {possp; prepnp(od,gen)} + {prepnp(dla,gen)}
rozkaz: : : : {possp} + {prepnp(dla,gen)} + {prepnp(przeciw,dat)}
rozkaz: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {cp(że)}
rozkaz: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {cp(żeby)}
rozkaz: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {or}
rozkaz: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
rozkaz: : : : {possp; prepnp(od,gen)} + {prepnp(dla,gen)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozkazać: _: : perf: subj,controller{np(str)} + controllee{np(str); infp(_)} + {np(dat)}
rozkazać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
rozkazać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rozkazać: _: : perf: subj{np(str)} + {np(dat)} + {or}
rozkazywać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
rozkazywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
rozkazywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rozkazywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
rozkazywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
rozkołysać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
rozkołysać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rozkołysać się: _: : perf: subj{np(str)} + {xp(locat)}
rozkołysać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozkołysać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozkopać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozkopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozkopywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rozkopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozkoszować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozkradać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
rozkraść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
rozkręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozkręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozkwitać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozkwitnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozlać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozlać się: _: : perf: subj{np(str)} + {xp(adl); xp(locat)}
rozlać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl); xp(locat)}
rozlatywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozlatywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozlatywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
rozlatywać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
rozlatywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rozlatywać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozlec się: _: : perf: subj{np(str)} + {xp(abl); xp(locat)} + {or}
rozlec się: _: : perf: subj{or} + {xp(abl)}
rozlec się: _: : perf: subj{or} + {xp(locat)}
rozlecieć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozlecieć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozlecieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
rozlecieć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
rozlecieć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozlecieć się: _: : perf: subj{np(str)} + {xp(adl)}
rozlegać się: _: : imperf: subj{np(str)} + {xp(abl); xp(locat)} + {or}
rozlegać się: _: : imperf: subj{or} + {xp(abl)}
rozlegać się: _: : imperf: subj{or} + {xp(locat)}
rozleniwiać się: _: : imperf: subj{np(str)} + {np(inst)}
rozleniwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozleniwić się: _: : perf: subj{np(str)} + {np(inst)}
rozleniwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozlewać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozlewać się: _: : imperf: subj{np(str)} + {xp(adl); xp(locat)}
rozlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl); xp(locat)}
rozleźć się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'palec',natr)}
rozleźć się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'ręka',natr)}
rozleźć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
rozleźć się: _: : perf: subj{np(str)} + {xp(adl)}
rozleźć się: _: : perf: subj{np(str)} + {xp(locat)}
rozliczać się: _: : imperf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
rozliczać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
rozliczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
rozliczać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
rozliczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
rozliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rozliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
rozliczyć się: _: : perf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
rozliczyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
rozliczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
rozliczyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
rozliczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
rozliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rozliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
rozlokować się: _: : perf: subj{np(str)} + {xp(locat)}
rozlokować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozlosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozlosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
rozlosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozluźnić się: _: : perf: subj{np(str)} + {np(dat)}
rozluźnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozładować się: _: : perf: subj{np(str)} + {np(dat)}
rozładować: _: : perf: subj{ncp(str,że)} + obj{np(str)}
rozładować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
rozładować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozładowywać się: _: : imperf: subj{np(str)} + {np(dat)}
rozładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
rozładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozłazić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'palec',natr)}
rozłazić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'ręka',natr)}
rozłazić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
rozłazić się: _: : imperf: subj{np(str)} + {xp(adl)}
rozłazić się: _: : imperf: subj{np(str)} + {xp(locat)}
rozłączać się: _: : imperf: subj{np(str)} + {np(dat)}
rozłączać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozłączać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {refl}
rozłączyć się: _: : perf: subj{np(str)} + {np(dat)}
rozłączyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozłączyć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
rozmarzać się: _: : imperf: subj{np(str)} + {cp(że)}
rozmarzać się: _: : imperf: subj{np(str)} + {cp(żeby)}
rozmarzać się: _: : imperf: subj{np(str)} + {or}
rozmarzać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby)}
rozmarzać: _: : imperf: subj{np(str)} + {np(str)}
rozmarzyć się: _: : perf: subj{np(str)} + {cp(że)}
rozmarzyć się: _: : perf: subj{np(str)} + {cp(żeby)}
rozmarzyć się: _: : perf: subj{np(str)} + {or}
rozmarzyć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby)}
rozmarzyć: _: : perf: subj{np(str)} + {np(str)}
rozmawiać: _: : imperf: subj{np(str)} + {or}
rozmawiać: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
rozmawiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
rozmawiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
rozmawiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
rozmazać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozmazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozmazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozmazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozmierzwić się: _: : perf: subj{np(str)} + {np(dat)}
rozmieszczać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozmieszczać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozmieścić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozmieścić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozmiękczać się: _: : imperf: subj{np(str)} + {np(dat)}
rozmiękczać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozmiękczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozmiękczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozmiękczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozmiękczyć się: _: : perf: subj{np(str)} + {np(dat)}
rozmiękczyć się: _: : perf: subj{np(str)} + {xp(locat)}
rozmiękczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozmiękczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozmiękczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozmijać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozminąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozmnażać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozmnażać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
rozmnażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozmnożyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozmnożyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
rozmnożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
rozmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
rozmrażać się: _: : imperf: subj{np(str)} + {np(dat)}
rozmrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozmrozić się: _: : perf: subj{np(str)} + {np(dat)}
rozmrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozmyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozmyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozmyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozmyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozmyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozmyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozmyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozmyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozmyślać się: _: : imperf: subj{np(str)}
rozmyślać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rozmyślać: _: : imperf: subj{np(str)} + {cp(int)}
rozmyślać: _: : imperf: subj{np(str)} + {cp(że)}
rozmyślać: _: : imperf: subj{np(str)} + {or}
rozmyślać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozmyślać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozmyślić się: _: : perf: subj{np(str)}
rozmyślić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozmywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozmywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozmywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozmywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozniecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozniecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
roznieść się: _: : perf: subj{cp(int)} + {prepnp(po,loc)}
roznieść się: _: : perf: subj{cp(int)} + {xp(locat)}
roznieść się: _: : perf: subj{cp(że)} + {prepnp(po,loc)}
roznieść się: _: : perf: subj{cp(że)} + {xp(locat)}
roznieść się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
roznieść się: _: : perf: subj{np(str)} + {xp(adl)}
roznieść się: _: : perf: subj{np(str)} + {xp(locat)}
roznieść: _: : perf: {np(str)}
roznieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
roznieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
roznosić się: _: : imperf: subj{cp(int)} + {prepnp(po,loc)}
roznosić się: _: : imperf: subj{cp(int)} + {xp(locat)}
roznosić się: _: : imperf: subj{cp(że)} + {prepnp(po,loc)}
roznosić się: _: : imperf: subj{cp(że)} + {xp(locat)}
roznosić się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
roznosić się: _: : imperf: subj{np(str)} + {xp(adl)}
roznosić się: _: : imperf: subj{np(str)} + {xp(locat)}
roznosić: _: : imperf: {np(str)}
roznosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
roznosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozochocić się: _: : perf: subj{np(str)} + {np(inst)}
rozochocić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozochocić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
rozpacz: : : : {fixed('czarna')}
rozpacz: : : : {possp} + {comprepnp(z powodu)}
rozpacz: : : : {possp} + {cp(że)}
rozpacz: : : : {possp} + {prepnp(nad,inst); prepncp(nad,inst,że)}
rozpacz: : : : {possp} + {prepnp(o,acc)}
rozpacz: : : : {possp} + {prepnp(po,loc)}
rozpacz: : : : {possp} + {prepnp(za,inst)}
rozpaczać: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
rozpaczać: _: : imperf: subj{np(str)} + {cp(int)}
rozpaczać: _: : imperf: subj{np(str)} + {cp(że)}
rozpaczać: _: : imperf: subj{np(str)} + {or}
rozpaczać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
rozpaczać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
rozpadać się: _: : perf: subj{E}
rozpadać się: _: : perf: subj{np(str)}
rozpadać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpadać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpakować się: _: : perf: subj{np(str)}
rozpakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpakowywać się: _: : imperf: subj{np(str)}
rozpakowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozpalać się: _: : imperf: subj{np(str)} + {np(inst)}
rozpalać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rozpalać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozpalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
rozpalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozpalić się: _: : perf: subj{np(str)} + {np(inst)}
rozpalić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
rozpalić się: _: : perf: subj{np(str)} + {xp(locat)}
rozpalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozpalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
rozpamiętywać: _: : imperf: subj{np(str)} + {cp(int)}
rozpamiętywać: _: : imperf: subj{np(str)} + {cp(jak)}
rozpamiętywać: _: : imperf: subj{np(str)} + {cp(że)}
rozpamiętywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
rozpamiętywać: _: : imperf: subj{np(str)} + {or}
rozpamiętywać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozparcelować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozparcelować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozpaść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpaść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpatrywać się: _: : imperf: subj{np(str)} + {cp(int)}
rozpatrywać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
rozpatrywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozpatrywać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpatrywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozpatrywać: _: : imperf: subj{np(str)} + obj{cp(int)}
rozpatrywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozpatrzeć się: _: : perf: subj{np(str)} + {cp(int)}
rozpatrzeć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
rozpatrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozpatrzeć się: _: : perf: subj{np(str)} + {xp(locat)}
rozpatrzeć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozpatrzeć: _: : perf: subj{np(str)} + obj{cp(int)}
rozpatrzeć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozpatrzyć się: _: : perf: subj{np(str)} + {cp(int)}
rozpatrzyć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
rozpatrzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozpatrzyć się: _: : perf: subj{np(str)} + {xp(locat)}
rozpatrzyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozpatrzyć: _: : perf: subj{np(str)} + obj{cp(int)}
rozpatrzyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozpędzić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozpędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpiąć się: _: : perf: subj{np(str)} + {np(dat)}
rozpiąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
rozpiąć się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
rozpiąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
rozpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
rozpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(między,inst)}
rozpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
rozpić się: _: : perf: subj{np(str)}
rozpić: _: : perf: subj{np(str)} + obj{np(str)}
rozpierać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpieszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozpieścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozpijać się: _: : imperf: subj{np(str)}
rozpijać: _: : imperf: subj{np(str)} + obj{np(str)}
rozpinać się: _: : imperf: subj{np(str)} + {np(dat)}
rozpinać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
rozpinać się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
rozpinać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
rozpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
rozpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(między,inst)}
rozpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
rozpisać się: _: : perf: subj{np(str)} + {comprepnp(co do)}
rozpisać się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
rozpisać się: _: : perf: subj{np(str)} + {cp(int)}
rozpisać się: _: : perf: subj{np(str)} + {cp(jak)}
rozpisać się: _: : perf: subj{np(str)} + {cp(że)}
rozpisać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozpisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozpisywać się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
rozpisywać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
rozpisywać się: _: : imperf: subj{np(str)} + {cp(int)}
rozpisywać się: _: : imperf: subj{np(str)} + {cp(jak)}
rozpisywać się: _: : imperf: subj{np(str)} + {cp(że)}
rozpisywać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozplanować: _: : perf: subj{np(str)} + obj{cp(int)}
rozplanować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozplanowywać: _: : imperf: subj{np(str)} + obj{cp(int)}
rozplanowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozplątać się: _: : perf: subj{np(str)} + {np(dat)}
rozplątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozplątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozplątać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozplątywać się: _: : imperf: subj{np(str)} + {np(dat)}
rozplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozplątywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozpłakać się: _: : perf: subj{np(str)} + {cp(że)}
rozpłakać się: _: : perf: subj{np(str)} + {or}
rozpłakać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozpłynąć się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
rozpłynąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozpłynąć się: _: : perf: subj{np(str)} + {xp(locat)}
rozpływać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,jak); prepncp(nad,inst,że)}
rozpływać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozpływać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpocząć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
rozpocząć się: _: : perf: subj{np(str)} + {np(inst)}
rozpocząć się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
rozpocząć się: _: : perf: subj{np(str)} + {xp(locat)}
rozpocząć się: _: : perf: subj{np(str)} + {xp(temp)}
rozpocząć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozpocząć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpocząć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
rozpoczynać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
rozpoczynać się: _: : imperf: subj{np(str)} + {np(inst)}
rozpoczynać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
rozpoczynać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpoczynać się: _: : imperf: subj{np(str)} + {xp(temp)}
rozpoczynać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozpoczynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpoczynać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
rozporządzać się: _: : imperf: subj{np(str)} + {np(inst)}
rozporządzać: _: : imperf: subj{np(str)} + {cp(int)}
rozporządzać: _: : imperf: subj{np(str)} + {cp(że)}
rozporządzać: _: : imperf: subj{np(str)} + {cp(żeby)}
rozporządzać: _: : imperf: subj{np(str)} + {np(inst)}
rozporządzić się: _: : perf: subj{np(str)} + {np(inst)}
rozporządzić: _: : perf: subj{np(str)} + {cp(int)}
rozporządzić: _: : perf: subj{np(str)} + {cp(że)}
rozporządzić: _: : perf: subj{np(str)} + {cp(żeby)}
rozporządzić: _: : perf: subj{np(str)} + {np(inst)}
rozpostrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozpostrzeć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rozpostrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
rozpostrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozpościerać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozpościerać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rozpościerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
rozpościerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozpowszechniać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpowszechniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpowszechnić się: _: : perf: subj{np(str)} + {xp(locat)}
rozpowszechnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpoznać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozpoznać: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
rozpoznać: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
rozpoznać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
rozpoznać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
rozpoznać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozpoznać: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozpoznać: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozpoznać: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {refl}
rozpoznawać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozpoznawać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
rozpoznawać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
rozpoznawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
rozpoznawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
rozpoznawać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozpoznawać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozpoznawać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozpoznawać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {refl}
rozpracować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpraszać się: _: : imperf: subj{np(str)} + {np(inst)}
rozpraszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozpraszać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
rozpraszać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozpraszać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpraszać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
rozpraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozpraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozpraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozpraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozprawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozprawiać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
rozprawiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
rozprawić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozpropagować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozproszyć się: _: : perf: subj{np(str)} + {np(inst)}
rozproszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozproszyć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
rozproszyć się: _: : perf: subj{np(str)} + {xp(adl)}
rozproszyć się: _: : perf: subj{np(str)} + {xp(locat)}
rozproszyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
rozproszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozproszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozproszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozproszyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozproszyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozprowadzać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
rozprowadzać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
rozprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {xp(perl)}
rozprowadzić się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
rozprowadzić się: _: : perf: subj{np(str)} + {xp(locat)}
rozprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
rozprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {xp(perl)}
rozpruć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozpruwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpruwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
rozpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozpryskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
rozpryskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
rozpryskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozpryskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozprysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
rozprysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozprysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozprysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
rozprysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozprysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozprysnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozprzestrzeniać się: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzeniać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozprzestrzeniać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozprzestrzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozprzestrzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozprzestrzenić się: _: : perf: subj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzenić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozprzestrzenić się: _: : perf: subj{np(str)} + {xp(locat)}
rozprzestrzenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozprzestrzenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpuszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozpuszczalny: : : : {np(inst)}
rozpuszczalny: : : : {prepnp(w,loc)}
rozpuścić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozpychać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
rozpychać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozpychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpychać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozpychać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpytać się: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
rozpytać się: _: : perf: subj{np(str)} + {np(gen)} + {cp(int)}
rozpytać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
rozpytać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
rozpytać: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
rozpytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
rozpytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
rozpytać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
rozpytać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
rozpytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
rozpytać: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
rozpytywać się: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
rozpytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {cp(int)}
rozpytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
rozpytywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
rozpytywać: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
rozpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
rozpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
rozpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
rozpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
rozpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
rozpytywać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {xp(locat)}
rozrastać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozrastać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozrastać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozrastać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozrosnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozrosnąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozrosnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozrosnąć się: _: : perf: subj{np(str)} + {xp(adl)}
rozróżniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozróżniać: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
rozróżniać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozróżniać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozróżniać: _: : imperf: subj{np(str)} + {prepnp(pomiędzy,inst)}
rozróżnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozróżnić: _: : perf: subj{np(str)} + {prepnp(między,inst)}
rozróżnić: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozróżnić: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozróżnić: _: : perf: subj{np(str)} + {prepnp(pomiędzy,inst)}
rozruszać się: _: : perf: subj{np(str)} + {np(dat)}
rozruszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozrywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozrywać: _: : imperf: {np(dat)} + {np(str)} + {prepnp(na,acc)}
rozrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozsądzać: _: : imperf: subj{np(str)} + {cp(int)}
rozsądzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozsądzić: _: : perf: subj{np(str)} + {cp(int)}
rozsądzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozstać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozstawać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozstawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozstawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozstawiać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
rozstawiać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
rozstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozstawić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozstawić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozstawić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
rozstawić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
rozstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozstawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozstawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozstąpić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
rozstąpić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
rozstępować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
rozstępować się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
rozstrajać się: _: : imperf: subj{np(str)} + {np(dat)}
rozstrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozstroić się: _: : perf: subj{np(str)} + {np(dat)}
rozstroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozstrzelać się: _: : perf: subj{np(str)}
rozstrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
rozstrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
rozstrzygać się: _: : imperf: subj{cp(int)}
rozstrzygać się: _: : imperf: subj{np(str); ncp(str,int)}
rozstrzygać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{cp(int)}
rozstrzygać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{cp(że)}
rozstrzygać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozstrzygać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozstrzygnąć się: _: : perf: subj{cp(int)}
rozstrzygnąć się: _: : perf: subj{np(str); ncp(str,int)}
rozstrzygnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{cp(int)}
rozstrzygnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{cp(że)}
rozstrzygnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozstrzygnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozsyłać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
rozsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rozsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
rozsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
rozsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
rozsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
rozsypać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozsypać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozsypać się: _: : perf: subj{np(str)} + {xp(adl)}
rozsypać się: _: : perf: subj{np(str)} + {xp(locat)}
rozsypać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozsypać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozsypać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozsypywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozsypywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozsypywać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozsypywać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozszabrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozszabrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
rozszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozszarpywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozszerzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
rozszerzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rozszerzać się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
rozszerzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozszerzać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
rozszerzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozszerzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozszerzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
rozszerzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozszerzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozszerzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
rozszerzyć się: _: : perf: subj{np(str)} + {np(inst)}
rozszerzyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
rozszerzyć się: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
rozszerzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozszerzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
rozszerzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozszerzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozszerzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
rozszerzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozszerzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozszyfrować: _: : perf: subj{np(str)} + obj{cp(int)}
rozszyfrować: _: : perf: subj{np(str)} + obj{cp(że)}
rozszyfrować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
rozszyfrowywać: _: : imperf: subj{np(str)} + obj{cp(int)}
rozszyfrowywać: _: : imperf: subj{np(str)} + obj{cp(że)}
rozszyfrowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
rozścielać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozścielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozścielić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozścielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozśmieszać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozśmieszać: _: : imperf: subj{cp(int)} + {np(str)}
rozśmieszać: _: : imperf: subj{cp(jak)} + {np(str)}
rozśmieszać: _: : imperf: subj{cp(jeśli)} + {np(str)}
rozśmieszać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozśmieszać: _: : imperf: subj{cp(że)} + {np(str)}
rozśmieszać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozśmieszać: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
rozśmieszać: _: : imperf: subj{np(str)} + {np(str)} + {or}
rozśmieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
rozśmieszyć: _: : perf: subj{cp(gdy)} + {np(str)}
rozśmieszyć: _: : perf: subj{cp(int)} + {np(str)}
rozśmieszyć: _: : perf: subj{cp(jak)} + {np(str)}
rozśmieszyć: _: : perf: subj{cp(jeśli)} + {np(str)}
rozśmieszyć: _: : perf: subj{cp(kiedy)} + {np(str)}
rozśmieszyć: _: : perf: subj{cp(że)} + {np(str)}
rozśmieszyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozśmieszyć: _: : perf: subj{np(str)} + {np(str)} + {cp(że)}
rozśmieszyć: _: : perf: subj{np(str)} + {np(str)} + {or}
rozśmieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
rozświetlać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozświetlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozświetlić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
rozświetlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
roztaczać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
roztaczać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
roztaczać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
roztaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
roztaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
roztaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
roztaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
roztaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
roztapiać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
roztapiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
roztapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
roztapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
roztapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
roztapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
roztkliwiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
roztkliwiać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
roztkliwiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
roztkliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
roztkliwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
roztkliwić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
roztkliwić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
roztkliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
roztoczyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
roztoczyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
roztoczyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
roztoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
roztoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
roztoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
roztoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
roztoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
roztopić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
roztopić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
roztopić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
roztopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
roztopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
roztopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
roztrącać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
roztrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
roztrącić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
roztrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
roztrwonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
roztrząsać: _: : imperf: subj{np(str)} + obj{cp(int)}
roztrząsać: _: : imperf: subj{np(str)} + obj{cp(że)}
roztrząsać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
roztrząsać: _: : imperf: subj{np(str)} + {or}
roztrząsnąć: _: : perf: subj{np(str)} + obj{cp(int)}
roztrząsnąć: _: : perf: subj{np(str)} + obj{cp(że)}
roztrząsnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
roztrząsnąć: _: : perf: subj{np(str)} + {or}
rozumieć się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
rozumieć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozumieć: _: : imperf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
rozumieć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
rozumieć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
rozumieć: _: : imperf: subj{np(str)} + obj{np(str)}
rozumieć: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
rozumieć: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {cp(że)}
rozumieć: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {ncp(str,że)}
rozumieć: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {nonch}
rozumować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
rozumować: _: : imperf: subj{np(str)} + {cp(że)}
rozumować: _: : imperf: subj{np(str)} + {np(inst)}
rozumować: _: : imperf: subj{np(str)} + {or}
rozważać: _: : imperf: subj{np(str)} + obj{cp(int)}
rozważać: _: : imperf: subj{np(str)} + obj{cp(że)}
rozważać: _: : imperf: subj{np(str)} + obj{cp(żeby)}
rozważać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
rozważać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozważać: _: : imperf: subj{np(str)} + {or}
rozważyć: _: : perf: subj{np(str)} + obj{cp(int)}
rozważyć: _: : perf: subj{np(str)} + obj{cp(że)}
rozważyć: _: : perf: subj{np(str)} + obj{cp(żeby)}
rozważyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
rozważyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozważyć: _: : perf: subj{np(str)} + {or}
rozweselać się: _: : imperf: subj{np(str)} + {np(inst)}
rozweselać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozweselać: _: : imperf: subj{cp(int)} + {np(str)}
rozweselać: _: : imperf: subj{cp(jak)} + {np(str)}
rozweselać: _: : imperf: subj{cp(jeśli)} + {np(str)}
rozweselać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozweselać: _: : imperf: subj{cp(że)} + {np(str)}
rozweselać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozweselać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozweselić się: _: : perf: subj{np(str)} + {np(inst)}
rozweselić: _: : perf: subj{cp(gdy)} + {np(str)}
rozweselić: _: : perf: subj{cp(int)} + {np(str)}
rozweselić: _: : perf: subj{cp(jak)} + {np(str)}
rozweselić: _: : perf: subj{cp(jeśli)} + {np(str)}
rozweselić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozweselić: _: : perf: subj{cp(że)} + {np(str)}
rozweselić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozweselić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozwiać się: _: : perf: subj{np(str)} + {np(dat)}
rozwiać się: _: : perf: subj{np(str)} + {xp(adl)}
rozwiać się: _: : perf: subj{np(str)} + {xp(locat)}
rozwiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwierać się: _: : imperf: subj{np(str)} + {np(dat)}
rozwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozwieść się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozwieść się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozwieść się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozwieść: _: : perf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
rozwiewać się: _: : imperf: subj{np(str)} + {np(dat)}
rozwiewać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozwiewać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozwiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rozwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozwijać się: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
rozwijać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
rozwijać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
rozwijać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozwijać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
rozwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
rozwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozwikłać się: _: : perf: subj{cp(int)}
rozwikłać się: _: : perf: subj{np(str); ncp(str,int)}
rozwikłać: _: : perf: subj{np(str)} + obj{cp(int)}
rozwikłać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
rozwikływać się: _: : imperf: subj{cp(int)}
rozwikływać się: _: : imperf: subj{np(str); ncp(str,int)}
rozwikływać: _: : imperf: subj{np(str)} + obj{cp(int)}
rozwikływać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
rozwinąć się: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
rozwinąć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
rozwinąć się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
rozwinąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozwinąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
rozwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
rozwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozwlec się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozwlec się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozwlec się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozwlec się: _: : perf: subj{np(str)} + {xp(locat)}
rozwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozwlec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozwlekać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozwlekać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozwlekać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozwlekać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozwlekać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozwodzić się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
rozwodzić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozwodzić się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozwodzić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rozwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozwydrzyć się: _: : perf: subj{np(str)} + {np(dat)}
rozwydrzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozwydrzyć: _: : perf: subj{np(str)} + obj{np(str)}
rozzłościć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozzłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
rozzłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozzłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozzłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozzłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rozzłościć: _: : perf: subj{cp(gdy)} + {np(str)}
rozzłościć: _: : perf: subj{cp(jak)} + {np(str)}
rozzłościć: _: : perf: subj{cp(jeśli)} + {np(str)}
rozzłościć: _: : perf: subj{cp(kiedy)} + {np(str)}
rozzłościć: _: : perf: subj{cp(że)} + {np(str)}
rozzłościć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozzłościć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozzuchwalać się: _: : imperf: subj{np(str)} + {np(inst)}
rozzuchwalać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
rozzuchwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozzuchwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozzuchwalić się: _: : perf: subj{np(str)} + {np(inst)}
rozzuchwalić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
rozzuchwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozzuchwalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozżalić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
rozżalić się: _: : perf: subj{np(str)} + {cp(int)}
rozżalić się: _: : perf: subj{np(str)} + {cp(że)}
rozżalić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozżalić się: _: : perf: subj{np(str)} + {or}
rozżalić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rozżalić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozżalić: _: : perf: subj{cp(gdy)} + {np(str)}
rozżalić: _: : perf: subj{cp(int)} + {np(str)}
rozżalić: _: : perf: subj{cp(jak)} + {np(str)}
rozżalić: _: : perf: subj{cp(jeśli)} + {np(str)}
rozżalić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozżalić: _: : perf: subj{cp(że)} + {np(str)}
rozżalić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozżalić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
równać się: _: : imperf: subj,controller{infp(_)} + controllee{infp(_)}
równać się: _: : imperf: subj,controller{infp(_)} + controllee{np(nom)}
równać się: _: : imperf: subj,controller{np(str)} + controllee{np(nom)}
równać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
równać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
równać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
równoważyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
równoważyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
równoważyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
różnica: : : : {np(gen)} + {comprepnp(na rzecz)}
różnica: : : : {np(gen)} + {comprepnp(w stosunku do)}
różnica: : : : {np(gen)} + {preplexnp(na,acc,sg,'korzyść',atr)}
różnica: : : : {np(gen)} + {preplexnp(na,acc,sg,'niekorzyść',atr)}
różnica: : : : {np(gen)} + {prepnp(między,inst)}
różnica: : : : {np(gen)} + {prepnp(wobec,gen)}
różnica: : : : {np(gen)} + {prepnp(względem,gen)}
różnica: : : : {prepnp(co do,gen)} + {prepnp(między,inst)}
różnica: : : : {prepnp(między,inst)} + {comprepnp(na temat)}
różnica: : : : {prepnp(między,inst)} + {comprepnp(w kwestii)}
różnica: : : : {prepnp(między,inst)} + {comprepnp(w sprawie)}
różnica: : : : {prepnp(między,inst)} + {cp(że)}
różnica: : : : {prepnp(między,inst)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
różnicować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
różnicować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
różnicować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
różnicować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
różnić się: _: : imperf: subj{np(str)} + {comprepnp(co do)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
różnić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); preplexnp(pod,inst,_,'wzgląd',atr)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
różnić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); preplexnp(pod,inst,_,'wzgląd',atr)} + {prepnp(od,gen)} + {advp(misc)}
różnić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); preplexnp(pod,inst,_,'wzgląd',atr)} + {prepnp(z,inst)} + {advp(misc)}
różnić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(co do)} + {advp(misc)}
różnić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)} + {advp(misc)}
różnić się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
różnić się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)} + {prepnp(z,inst)} + {advp(misc)}
różnić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
różnić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)} + {advp(misc)}
różnić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen)} + {advp(misc)}
różnić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(z,inst)} + {advp(misc)}
różnić: _: : imperf: subj{np(str)} + {np(str)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
rugować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
rujnować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rujnować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
rujnować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rumienić się: _: : imperf: subj{np(str)} + {cp(że)}
rumienić się: _: : imperf: subj{np(str)} + {np(inst)}
rumienić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
rumienić się: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rumienić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rumienić: _: : imperf: subj{np(str)} + obj{np(str)}
runąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
runąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
runąć: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
ruszać się: _: : imperf: subj{np(str)} + {np(dat)}
ruszać się: _: : imperf: subj{np(str)} + {xp(abl)}
ruszać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(inst,sg,'palec',natr)}
ruszać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ruszać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
ruszać: _: : imperf: subj{np(str)} + {np(inst)}
ruszać: _: : imperf: subj{np(str)} + {np(str)}
ruszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
ruszać: _: : imperf: subj{np(str)} + {preplexnp(z,gen,sg,'kopyto',natr)}
ruszać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
ruszać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
ruszać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(temp)}
ruszyć się: _: : perf: subj{np(str)} + {np(dat)}
ruszyć się: _: : perf: subj{np(str)} + {xp(abl)}
ruszyć: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(inst,sg,'palec',natr)}
ruszyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
ruszyć: _: : perf: subj{np(str)} + {np(inst)}
ruszyć: _: : perf: subj{np(str)} + {np(str)}
ruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
ruszyć: _: : perf: subj{np(str)} + {preplexnp(z,gen,sg,'kopyto',natr)}
ruszyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
ruszyć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
ruszyć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
ruszyć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(temp)}
rwać się: _: : imperf: subj{np(str)} + {cp(żeby)}
rwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rwać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
rwać się: _: : imperf: subj{np(str)} + {xp(adl)}
rwać: _: : imperf: {np(str)} + {xp(locat)}
rwać: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'włos',natr)} + {lexnp(dat,_,'siebie',natr)} + {preplexnp(z,gen,sg,'głowa',natr)}
rwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rwać: _: : imperf: subj{np(str)} + {xp(adl)}
rycerski: : : : {comprepnp(w stosunku do)}
rycerski: : : : {prepnp(dla,gen)}
rycerski: : : : {prepnp(wobec,gen)}
rycerski: : : : {prepnp(względem,gen)}
ryczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {or}
ryczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {or}
ryczeć: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
ryczeć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
ryczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
ryć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ryć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
ryć się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
ryć się: _: : imperf: subj{np(str)} + {xp(adl)}
ryć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
ryć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
ryć: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'blacha',natr)}
ryć: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pamięć',natr)}
ryć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
ryć: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
ryć: _: : imperf: subj{np(str)} + {xp(locat)}
ryknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {or}
ryknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {or}
ryknąć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
ryknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
ryknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
ryknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
ryknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
ryknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
ryknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
ryknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
rymować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rymować: _: : imperf: subj{np(str)} + obj{np(str)}
rypnąć się: _: : perf: {np(dat)}
rypnąć się: _: : perf: subj{np(str)} + {np(dat)}
rypnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
rypnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rypnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rypnąć się: _: : perf: subj{np(str)} + {xp(adl)}
rypnąć: _: : perf: subj{E}
rypnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
rypnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rypnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
rypnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
rypnąć: _: : perf: subj{np(str)} + {np(part)}
rypnąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
rypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rypnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rysować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
rysować się: _: : imperf: subj{np(str)} + {xp(locat)}
rysować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rysować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rysować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
rysować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rywalizować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {preplexnp(między,inst,_,'siebie',natr)}
rywalizować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
rywalizować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
ryzyko: : : : {comprepnp(co do)}
ryzyko: : : : {comprepnp(po stronie)}
ryzyko: : : : {comprepnp(w stosunku do)}
ryzyko: : : : {np(gen); cp(że); ncp(gen,że)} + {possp}
ryzyko: : : : {prepnp(dla,gen)}
ryzyko: : : : {prepnp(wobec,gen)}
ryzykować: _: : imperf: subj{np(str)} + {cp(że)}
ryzykować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
ryzykować: _: : imperf: subj{np(str)} + {np(str); ncp(str,że)}
rządzić się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
rządzić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rządzić: _: : imperf: subj{np(str)} + obj{np(inst); ncp(inst,int); ncp(inst,że)}
rządzić: _: : imperf: subj{np(str)} + {xp(locat)}
rzec: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
rzec: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
rzec: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rzec: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
rzec: _: : perf: subj{np(str)} + {np(dat)} + {or}
rzec: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
rzednąć: _: : imperf: subj{np(str)} + {np(dat)}
rzednieć: _: : imperf: subj{np(str)} + {np(dat)}
rzeźbić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
rzępolić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rzucać się: _: : imperf: {np(dat)} + {prepnp(na,acc)}
rzucać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
rzucać się: _: : imperf: subj{cp(int)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: _: : imperf: subj{cp(jak)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rzucać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rzucać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rzucać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
rzucać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rzucać: _: : imperf: {np(inst)} + {advp(misc)}
rzucać: _: : imperf: {np(inst)} + {prepnp(po,loc)}
rzucać: _: : imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
rzucać: _: : imperf: {np(str)} + {prepnp(po,loc)}
rzucać: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
rzucać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {preplexnp(na,acc,pl,'kolano',natr)}
rzucać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {cp(że)}
rzucać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
rzucać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'światło',atr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucać: _: : imperf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
rzucać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
rzucać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
rzucać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
rzucać: _: : imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
rzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rzucać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
rzucać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
rzucić się: _: : perf: {np(dat)} + {prepnp(na,acc)}
rzucić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
rzucić się: _: : perf: subj{cp(int)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: _: : perf: subj{cp(jak)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: _: : perf: subj{cp(żeby2)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rzucić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rzucić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rzucić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
rzucić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rzucić: _: : perf: {np(inst)} + {advp(misc)}
rzucić: _: : perf: {np(inst)} + {xp(adl)}
rzucić: _: : perf: {np(str)} + {xp(adl)}
rzucić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {preplexnp(na,acc,pl,'kolano',natr)}
rzucić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {cp(że)}
rzucić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
rzucić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucić: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'światło',atr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucić: _: : perf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
rzucić: _: : perf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
rzucić: _: : perf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
rzucić: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
rzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzucić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rzucić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
rzucić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
rzutować: _: : imperf: subj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{xp(mod)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
rzutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rzygać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,jak); ncp(inst,że)}
rzygać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
rzygać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
rzygać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
rzygać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rżnąć się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
rżnąć: _: : _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
rżnąć: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rżnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rżnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rżnąć: _: : imperf: {np(str)} + {xp(locat)}
rżnąć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
rżnąć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(od,gen,sg,'ucho',natr)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rżnąć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
rżnąć: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sadowić się: _: : imperf: subj{np(str)} + {xp(locat)}
sadowić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
sadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
sadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
sadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
sadzić się: _: : imperf: subj{np(str)} + {cp(żeby)}
sadzić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
sadzić: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
sadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
salutować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
salutować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
sankcjonować: _: : imperf: subj{np(str)} + obj{cp(że)}
sankcjonować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
satysfakcjonować: _: : imperf: subj{cp(gdy)} + {np(str)}
satysfakcjonować: _: : imperf: subj{cp(int)} + {np(str)}
satysfakcjonować: _: : imperf: subj{cp(jak)} + {np(str)}
satysfakcjonować: _: : imperf: subj{cp(jeśli)} + {np(str)}
satysfakcjonować: _: : imperf: subj{cp(kiedy)} + {np(str)}
satysfakcjonować: _: : imperf: subj{cp(że)} + {np(str)}
satysfakcjonować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
satysfakcjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
sączyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
sączyć się: _: : imperf: subj{np(str)} + {np(inst)}
sączyć się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
sączyć się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
sączyć się: _: : imperf: subj{np(str)} + {xp(locat)}
sączyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
sączyć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
sączyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
sączyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
sączyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
sączyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sąd: : : : {adjp(agr)} + {xp(locat)}
sąd: : : : {possp} + {comprepnp(na temat)}
sąd: : : : {possp} + {comprepnp(w kwestii)}
sąd: : : : {possp} + {comprepnp(w sprawie)}
sąd: : : : {possp} + {cp(int)}
sąd: : : : {possp} + {cp(jakoby)}
sąd: : : : {possp} + {cp(że)}
sąd: : : : {possp} + {cp(żeby)}
sąd: : : : {possp} + {or}
sąd: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
sąd: : : : {possp} + {prepnp(nad,inst); prepncp(nad,inst,int)}
sąd: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
sądzić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
sądzić: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
sądzić: _: : imperf: subj{np(str)} + {cp(żeby2)}
sądzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
sądzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sądzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
sądzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
sądzić: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
sądzić: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
sądzić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
sąsiadować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
sąsiadować: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
sąsiadować: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)}
scalać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
scalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
scalić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
scalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
scentralizować się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
scentralizować się: _: : perf: subj{np(str)} + {xp(locat)}
scentralizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
scharakteryzować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
scharakteryzować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
scharakteryzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
scharakteryzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
scharakteryzować: _: : perf: subj{np(str)} + obj{cp(int)}
schładzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
schładzać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
schładzać się: _: : imperf: subj{np(str)} + {xp(locat)}
schładzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
schładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
schładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
schładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
schładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
schładzać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
schłodzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
schłodzić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
schłodzić się: _: : perf: subj{np(str)} + {xp(locat)}
schłodzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
schłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
schłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
schłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
schłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
schłodzić: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
schodzić się: _: : perf: subj{np(str)}
schodzić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
schodzić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
schodzić się: _: : imperf: subj{np(str)} + {xp(adl)}
schodzić się: _: : imperf: subj{np(str)} + {xp(locat)}
schodzić: _: : perf: subj{np(str)} + obj{np(str)}
schodzić: _: : imperf: {comprepnp(na temat)}
schodzić: _: : imperf: {np(dat)} + {prepnp(na,loc)}
schodzić: _: : imperf: {prepnp(na,acc)}
schodzić: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
schodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
schodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
schodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
schodzić: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
schodzić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
schować się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
schować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
schować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(adl)}
schować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
schować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
schować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
schować: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)} + {refl}
schować: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
schronić się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
schronić się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
schronić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
schronić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
schronić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
schronić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
schudnąć: _: : perf: subj{np(str)} + {np(str)}
schudnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
schudnąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
schudnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
schwycić się: _: : perf: subj{np(str)} + {np(gen)}
schwycić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
schwycić: _: : perf: subj{np(str)}
schwycić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
schwycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
schwycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
schwytać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
schwytać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
schwytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
schylać się: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
schylać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
schylać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
schylić się: _: : perf: subj{np(str)} + {prepnp(po,acc)}
schylić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
schylić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
selekcjonować: _: : imperf: subj{np(str)} + {cp(int)}
selekcjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
selekcjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sens: : : : {cp(że)}
sens: : : : {cp(żeby)}
sens: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
sens: : : : {or}
serdeczny: : : : {comprepnp(w stosunku do)}
serdeczny: : : : {prepnp(dla,gen)}
serdeczny: : : : {prepnp(wobec,gen)}
serdeczny: : : : {prepnp(względem,gen)}
serwować: _: : imperf: subj{np(str)} + {np(inst)}
serwować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
sędziować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
sędziować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
sędziować: _: : imperf: subj{np(str)} + {xp(locat)}
sfałszować: _: : perf: subj{np(str)} + {cp(że)}
sfałszować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sfatygować się: _: : perf: subj{np(str)}
sfatygować się: _: : perf: subj{np(str)} + {np(inst)}
sfatygować: _: : perf: subj{np(str)} + obj{np(str)}
sfaulować: _: : perf: subj{np(str)} + obj{np(str)}
sfilmować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
sfilmować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
sfilmować: _: : perf: subj{np(str)} + obj{cp(jak)} + {np(inst)}
sfilmować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak)} + {np(inst)}
sfinalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sfinansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sfinansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sformalizować się: _: : perf: subj{np(str)}
sformalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
sformatować się: _: : perf: subj{np(str)} + {np(dat)}
sformatować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)}
sformatować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sformatować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sformować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
sformować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
sformować się: _: : perf: subj{np(str)} + {xp(locat)}
sformować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
sformować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sformować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
sformułować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
sformułować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
sforsować się: _: : perf: subj{np(str)} + {np(inst)}
sforsować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
sforsować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
sfotografować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
sfotografować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
siać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
siać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
siadać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
siadać: _: : imperf: subj{np(str)} + {xp(adl)}
siadać: _: : imperf: subj{np(str)} + {xp(locat)}
siąść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
siąść: _: : perf: subj{np(str)} + {xp(adl)}
siąść: _: : perf: subj{np(str)} + {xp(locat)}
siedzieć: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
siedzieć: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'kamień',natr)}
siedzieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'kark',natr)}
siedzieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
siedzieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
siedzieć: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
siedzieć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
siedzieć: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
siedzieć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
siedzieć: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {xp(dur)}
silić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
silić się: _: : imperf: subj{np(str)} + {cp(żeby)}
silić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
siłować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
siodłać: _: : imperf: subj{np(str)} + obj{np(str)}
siorbać: _: : imperf: subj{np(str)} + {np(inst)}
siorbać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
siorbnąć: _: : perf: subj{np(str)} + {np(inst)}
siorbnąć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
siwieć: _: : imperf: subj{np(str)} + {np(dat)}
siwieć: _: : imperf: subj{np(str)} + {xp(locat)}
siwieć: _: : imperf: {xp(locat)}
skakać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skakać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
skakać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
skakać: _: : imperf: subj{np(str)} + obj{np(str)}
skakać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
skakać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
skakać: _: : imperf: subj{np(str)} + {prepnp(koło,gen)}
skakać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
skakać: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
skakać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
skakać: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
skakać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,acc,sg,'ogień',natr)}
skakać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
skalać się: _: : perf: subj{np(str)} + {np(inst)}
skalać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
skalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skaleczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
skaleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
skaleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
skaleczyć: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
skalkulować się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
skalkulować się: _: : perf: subj{cp(żeby)} + {np(dat)}
skalkulować się: _: : perf: subj{np(str)} + {advp(misc)}
skalkulować się: _: : perf: subj{np(str)} + {np(dat)}
skalkulować: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
skalkulować: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
skalkulować: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
skalkulować: _: : perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
skalkulować: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
skamlać: _: : imperf: subj{np(str)} + {cp(że)}
skamlać: _: : imperf: subj{np(str)} + {cp(żeby)}
skamlać: _: : imperf: subj{np(str)} + {or}
skamlać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
skamlać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
skamleć: _: : imperf: subj{np(str)} + {cp(że)}
skamleć: _: : imperf: subj{np(str)} + {cp(żeby)}
skamleć: _: : imperf: subj{np(str)} + {or}
skamleć: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
skamleć: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
skanalizować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skanalizować się: _: : perf: subj{np(str)} + {xp(locat)}
skanalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skanalizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
skanalizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
skandować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
skandować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
skandować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
skandować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
skandować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
skandować: _: : imperf: subj{np(str)} + {prepnp(ku,dat)} + {or}
skanować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skanować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skanować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
skanować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
skapitulować: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
skapitulować: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
skapnąć się: _: : perf: subj{np(str)} + {cp(int)}
skapnąć się: _: : perf: subj{np(str)} + {cp(że)}
skapnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skapnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
skapnąć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
skarcić: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
skarcić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
skarcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
skarcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
skarcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {or}
skarcić: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {or} + {refl}
skarga: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,że)} + {prepnp(do,gen)}
skarga: : : : {possp} + {prepnp(do,gen)} + {comprepnp(na temat)}
skarga: : : : {possp} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
skarga: : : : {possp} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
skarga: : : : {possp} + {prepnp(do,gen)} + {comprepnp(z powodu)}
skarga: : : : {possp} + {prepnp(do,gen)} + {cp(jakoby)}
skarga: : : : {possp} + {prepnp(do,gen)} + {cp(że)}
skarga: : : : {possp} + {prepnp(do,gen)} + {cp(żeby)}
skarga: : : : {possp} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,że)}
skarga: : : : {possp} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
skarga: : : : {possp} + {prepnp(do,gen)} + {prepnp(wobec,gen)}
skarga: : : : {possp} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
skarżyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int); cp(że)}
skarżyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
skarżyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
skarżyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int); cp(że)}
skarżyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {or}
skarżyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
skarżyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
skarżyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
skarżyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {or}
skarżyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
skarżyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
skarżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
skarżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
skarżyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int)}
skarżyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
skarżyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
skasować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
skasować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(abl)}
skasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
skasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
skatować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {fixed('na kwaśne jabłko')}
skatować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {preplexnp(na,acc,sg,'miazga',atr)}
skazać się: _: : perf: subj{np(str)} + {prepncp(na,acc,że)}
skazać się: _: : perf: subj{np(str)} + {prepncp(na,acc,żeby)}
skazać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
skazać: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(na,acc,że)}
skazać: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(na,acc,żeby)}
skazać: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(za,acc,że)}
skazać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
skazać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
skazić się: _: : perf: subj{np(str)} + {np(inst)}
skazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skazywać się: _: : imperf: subj{np(str)} + {prepncp(na,acc,że)}
skazywać się: _: : imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
skazywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
skazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(na,acc,że)}
skazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(na,acc,żeby)}
skazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(za,acc,że)}
skazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
skazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
skąpić: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
skąpić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
skąpić: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
skierować się: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
skierować się: _: : perf: subj{np(str)} + {xp(adl)}
skierować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
skierować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
skierować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
skinąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
skinąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
skinąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
skinąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
sklasyfikować się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
sklasyfikować się: _: : perf: subj{np(str)} + {xp(locat)}
sklasyfikować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
sklasyfikować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
sklasyfikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
sklasyfikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
sklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
sklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
sklasyfikować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
sklasyfikować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
skleić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
skleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(z,inst)}
skleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
skleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
skleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,acc)} + {prepnp(z,inst)}
skleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
sklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(z,inst)}
sklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sklepić się: _: : perf: subj{np(str)} + {xp(locat)}
sklepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
sklonować: _: : perf: subj{np(str)} + obj{np(str)}
sklonować: _: : perf: subj{np(str)} + {refl}
składać się: _: : imperf: {np(dat)} + {cp(że)} + {advp(misc)}
składać się: _: : imperf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
składać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
składać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
składać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(po,acc)}
składać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
składać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
składać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
składać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
składać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
składać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
składować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skłamać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
skłamać: _: : perf: subj{np(str)} + {or}
skłamać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
skłamać: _: : perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
skłaniać się: _: : imperf: subj{np(str)} + {preplexnp(w,acc,sg,'strona',ratr)}
skłaniać się: _: : imperf: subj{np(str)} + {preplexnp(w,loc,sg,'kierunek',ratr)}
skłaniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
skłaniać się: _: : imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
skłaniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {cp(żeby)}
skłaniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {preplexnp(w,acc,sg,'strona',natr)}
skłaniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {preplexnp(w,loc,sg,'kierunek',natr)}
skłaniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
skłaniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
skłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
skłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
skłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
skłonić się: _: : perf: subj{np(str)} + {np(dat)}
skłonić się: _: : perf: subj{np(str)} + {preplexnp(w,acc,sg,'strona',ratr)}
skłonić się: _: : perf: subj{np(str)} + {preplexnp(w,loc,sg,'kierunek',ratr)}
skłonić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
skłonić się: _: : perf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
skłonić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {cp(żeby)}
skłonić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {preplexnp(w,acc,sg,'strona',ratr)}
skłonić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {preplexnp(w,loc,sg,'kierunek',ratr)}
skłonić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
skłonić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
skłonić: _: : perf: subj{np(str)} + {np(str)} + {xp(adl)}
skłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
skłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
skłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat); prepncp(ku,dat,że); prepncp(ku,dat,żeby)}
skoczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skoczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
skoczyć: _: : perf: subj{np(str)} + obj{np(str)}
skoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
skoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
skoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
skoczyć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
skoczyć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,acc,sg,'ogień',natr)}
skoczyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
skojarzyć się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
skojarzyć się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
skojarzyć się: _: : perf: subj{cp(jak)} + {np(dat)} + {advp(misc)}
skojarzyć się: _: : perf: subj{cp(że)} + {np(dat)} + {advp(misc)}
skojarzyć się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,jak); prepncp(z,inst,jakby); prepncp(z,inst,że); prepncp(z,inst,żeby)}
skojarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
skojarzyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skojarzyć: _: : perf: subj{np(str)} + {cp(int); cp(że)}
skojarzyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
skojarzyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
skojarzyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,jak); prepncp(z,inst,że); prepncp(z,inst,żeby)}
skojarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
skolonizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skołować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
skołować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skołować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
skołować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skomentować: _: : perf: subj{np(str)} + {cp(że)}
skomentować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {or}
skomleć: _: : imperf: subj{np(str)} + {cp(że)}
skomleć: _: : imperf: subj{np(str)} + {cp(żeby)}
skomleć: _: : imperf: subj{np(str)} + {or}
skomleć: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
skomleć: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
skomplikować się: _: : perf: subj{np(str)} + {np(dat)}
skomplikować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
skomplikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
skomponować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
skomponować się: _: : perf: subj{np(str)} + {xp(locat)}
skomponować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
skomponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skompromitować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
skompromitować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
skompromitować: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(przed,inst)}
skompromitować: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(wobec,gen)}
skompromitować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
skompromitować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
skomputeryzować się: _: : perf: subj{np(str)}
skomputeryzować: _: : perf: subj{np(str)} + obj{np(str)}
skonać: _: : perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
skonać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
skonać: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
skoncentrować się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
skoncentrować się: _: : perf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że); prepncp(wokół,gen,żeby)}
skoncentrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
skoncentrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skonfiskować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na rzecz)}
skonfrontować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
skonfrontować: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)} + {refl}
skonkretyzować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skonkretyzować: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
skonkretyzować: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
skonkretyzować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
skonkretyzować: _: : perf: subj{np(str)} + {or}
skonsolidować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
skonsolidować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skonsolidować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skonsolidować się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
skonsolidować się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
skonsolidować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
skonsolidować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
skonsolidować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
skonsolidować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
skonsolidować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
skonstatować: _: : perf: subj{np(str)} + {cp(int)}
skonstatować: _: : perf: subj{np(str)} + {cp(że)}
skonstatować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
skonstatować: _: : perf: subj{np(str)} + {or}
skonstruować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skonsultować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
skonsultować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
skonsultować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
skonsultować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
skonsultować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
skonsultować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
skonsultować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
skonsultować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
skonsultować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
skonsumować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skonsumować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
skontaktować się: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
skontaktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skontrolować: _: : perf: subj{np(str)} + {cp(int)} + {refl}
skontrolować: _: : perf: subj{np(str)} + {cp(że)}
skontrolować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
skontrolować: _: : perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
skończyć się: _: : perf: {prepnp(na,loc); prepncp(na,loc,że)}
skończyć się: _: : perf: subj{np(str)} + {np(inst)}
skończyć się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
skończyć się: _: : perf: subj{np(str)} + {xp(temp)}
skończyć: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
skończyć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
skończyć: _: : perf: subj{np(str)} + obj{np(str)}
skończyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
skoordynować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skopać się: _: : perf: subj{np(str)} + {np(dat)}
skopać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)} + {refl}
skopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
skopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
skopiować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skopiować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
skorelować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
skorelować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
skorumpować się: _: : perf: subj{np(str)}
skorumpować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skorygować: _: : perf: subj{np(str)} + {cp(że)}
skorygować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skorygować: _: : perf: subj{np(str)} + {or}
skorzystać: _: : perf: subj{np(str)} + {cp(że)}
skorzystać: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
skorzystać: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że); prepncp(z,gen,żeby)}
skosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
skosztować: _: : perf: subj{np(str)} + obj{np(part)}
skowyczeć: _: : imperf: {prepnp(z,gen)} + {xp(locat)}
skowyczeć: _: : imperf: subj{np(str)} + {cp(że)}
skowyczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
skowyczeć: _: : imperf: subj{np(str)} + {np(inst)} + {or}
skowyczeć: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
skowyczeć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
skowyczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
skowyczeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
skracać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
skracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
skraplać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
skraplać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
skraplać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
skraplać: _: : imperf: subj{np(str)} + obj{np(str)}
skraść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
skrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
skrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
skrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skreślać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
skreślać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skreślić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
skreślić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
skręcać się: _: : imperf: subj{np(str)} + {xp(adl)}
skręcać: _: : imperf: {np(str)} + {prepnp(z,gen)}
skręcać: _: : imperf: {np(str)} + {xp(locat)}
skręcać: _: : imperf: subj{cp(gdy)} + {np(str)}
skręcać: _: : imperf: subj{cp(jak)} + {np(str)}
skręcać: _: : imperf: subj{cp(jeśli)} + {np(str)}
skręcać: _: : imperf: subj{cp(kiedy)} + {np(str)}
skręcać: _: : imperf: subj{cp(żeby)} + {np(str)}
skręcać: _: : imperf: subj{cp(że)} + {np(str)}
skręcać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
skręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
skręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
skręcić się: _: : perf: subj{np(str)} + {xp(adl)}
skręcić: _: : perf: {np(str)} + {prepnp(z,gen)}
skręcić: _: : perf: {np(str)} + {xp(locat)}
skręcić: _: : perf: subj{cp(gdy)} + {np(str)}
skręcić: _: : perf: subj{cp(jak)} + {np(str)}
skręcić: _: : perf: subj{cp(jeśli)} + {np(str)}
skręcić: _: : perf: subj{cp(kiedy)} + {np(str)}
skręcić: _: : perf: subj{cp(żeby)} + {np(str)}
skręcić: _: : perf: subj{cp(że)} + {np(str)}
skręcić: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
skręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skręcić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
skrępować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skrobać się: _: : imperf: subj{np(str)} + {xp(adl)}
skrobać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
skrobać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
skrobać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
skrobać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
skrobać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
skrobać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
skrobać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
skrobać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
skrobać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
skrobać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
skrobać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
skrobać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
skrobać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
skrobać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
skrobać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
skroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
skroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
skroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skroplić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skroplić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skroplić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
skroplić: _: : perf: subj{np(str)} + obj{np(str)}
skrócić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
skrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
skryć się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
skryć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
skryć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
skryć się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
skryć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(przed,inst)}
skryć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,_,'siebie',natr)}
skryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
skryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
skryć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
skrytykować: _: : perf: subj{np(str)} + obj{cp(int)}
skrytykować: _: : perf: subj{np(str)} + obj{cp(że)}
skrytykować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
skrytykować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
skrytykować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
skrytykować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
skrytykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
skrywać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
skrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
skrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
skrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
skrywać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
skrywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(przed,inst)}
skrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,_,'siebie',natr)}
skrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
skrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
skrywać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
skrzeczeć: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
skrzeczeć: _: : imperf: subj{np(str)} + {cp(że)}
skrzeczeć: _: : imperf: subj{np(str)} + {np(inst)}
skrzeczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepadjp(po,postp)}
skrzeczeć: _: : imperf: subj{np(str)} + {or}
skrzeczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
skrzeczeć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
skrzyć się: _: : imperf: {np(inst)} + {xp(locat)}
skrzyć się: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
skrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
skrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
skrzyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
skrzyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skrzyć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
skrzypieć: _: : imperf: {np(dat)} + {xp(locat)}
skrzypieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
skrzypieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skrzypnąć: _: : perf: {np(dat)} + {xp(locat)}
skrzypnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
skrzypnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skrzywdzić: _: : perf: subj{cp(int)} + {np(str)}
skrzywdzić: _: : perf: subj{cp(że)} + {np(str)}
skrzywdzić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
skrzywdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
skrzywdzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
skrzywdzić: _: : perf: subj{np(str)} + {refl}
skrzywić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
skrzywić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
skrzywić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
skrzywić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
skrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
skrzyżować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {xp(locat)}
skrzyżować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skserować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
skubać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
skubać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
skubać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
skubać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
skubać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skubnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
skubnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
skubnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
skubnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
skubnąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)} + {xp(abl)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
skubnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skuć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
skuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
skuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
skulić się: _: : perf: subj{np(str)} + {xp(locat)}
skulić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skupiać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepnp(nad,inst); prepncp(na,loc,int); prepncp(na,loc,żeby)}
skupiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
skupiać się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
skupiać się: _: : imperf: subj{np(str)} + {xp(locat)}
skupiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
skupiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
skupić się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepnp(nad,inst); prepncp(na,loc,int); prepncp(na,loc,żeby)}
skupić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skupić się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
skupić się: _: : perf: subj{np(str)} + {xp(locat)}
skupić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
skupić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
skupić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
skupić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skupować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
skupować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
skupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skurczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skurczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skurczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skurczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
skurwić się: _: : perf: subj{np(str)} + {np(inst)}
skurwić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
skurwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
skurwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skusić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
skusić się: _: : perf: subj{np(str)} + {cp(żeby)}
skusić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
skusić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
skusić: _: : perf: subj,controllee{infp(_)} + controller{np(str)}
skusić: _: : perf: subj{cp(żeby)} + {np(str)}
skusić: _: : perf: subj{cp(że)} + {np(str)}
skusić: _: : perf: subj{np(str)} + controller{np(str)} + controllee{infp(_)}
skusić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
skusić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
skusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(żeby)}
skusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
skusić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
skutek: : : : {cp(że)}
skutek: : : : {np(gen); ncp(gen,int); ncp(gen,jakoby); ncp(gen,że)} + {prepnp(dla,gen)}
skutkować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
skutkować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
skuwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
skuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
skuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
skwierczeć: _: : imperf: subj{np(str)} + {cp(że)}
skwierczeć: _: : imperf: subj{np(str)} + {nonch}
skwierczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skwierczeć: _: : imperf: {xp(locat)}
skwitować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
skwitować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
skwitować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
słabnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
słabnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
słabnąć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
słać się: _: : imperf: subj{np(str)} + {xp(locat)}
słać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
słać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
słać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
słać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
sławić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
sławić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
słodzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
słodzić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
słodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
słuchać się: _: : imperf: subj{np(str)} + {np(gen)}
słuchać: _: : imperf: subj{np(str)} + {cp(int)}
słuchać: _: : imperf: subj{np(str)} + {cp(że)}
słuchać: _: : imperf: subj{np(str)} + {np(gen); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
słuchać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
słuchać: _: : imperf: subj{np(str)} + {np(str)}
słuchać: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)} + {np(inst)}
służyć: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
służyć: _: : imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {np(dat)}
służyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
służyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(dla,gen)}
służyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
służyć: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
służyć: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
służyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
słychać: _: : imperf: {cp(int)} + {xp(locat)}
słychać: _: : imperf: {cp(jak)} + {xp(locat)}
słychać: _: : imperf: {cp(że); cp(żeby2)} + {xp(locat)}
słychać: _: : imperf: {ncp(str,int)} + {xp(locat)}
słychać: _: : imperf: {ncp(str,jak)} + {xp(locat)}
słychać: _: : imperf: {np(str); ncp(str,że); or} + {xp(locat)}
słychać: _: : imperf: {prepncp(o,loc,int); prepncp(o,loc,jak)} + {xp(locat)}
słychać: _: : imperf: {prepncp(o,loc,że)} + {xp(locat)}
słychać: _: : imperf: {prepnp(o,loc)} + {xp(locat)}
słynąć: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
słynąć: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
słynąć: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
słynąć: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
słyszeć: _: : imperf: subj{np(str)} + obj{cp(jakoby)}
słyszeć: _: : imperf: subj{np(str)} + obj{cp(jak)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: _: : imperf: subj{np(str)} + obj{cp(żeby2)}
słyszeć: _: : imperf: subj{np(str)} + obj{cp(że)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(jak); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(inst)}
słyszeć: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: _: : imperf: subj{np(str)} + obj{np(str); prepnp(o,loc); cp(int); cp(jak); cp(że); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(od,gen)}
słyszeć: _: : imperf: subj{np(str)} + {prepncp(o,loc,jakoby)}
słyszeć: _: : imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
słyszeć: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {or}
słyszeć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby2)} + {nonch}
słyszeć: _: : imperf: subj{np(str)} + {refl}
smakować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
smakować: _: : imperf: subj{np(str)} + {np(dat)}
smakować: _: : imperf: subj{np(str)} + obj{np(str)}
smarować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
smarować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
smarować: _: : imperf: subj{np(str)} + {xp(adl)}
smażyć się: _: : imperf: subj{np(str)} + {advp(misc)}
smażyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
smażyć się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
smażyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
smażyć się: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(locat)}
smażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
smażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
smażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
smażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
smażyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
smucić się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
smucić się: _: : imperf: subj{np(str)} + {cp(int)}
smucić się: _: : imperf: subj{np(str)} + {cp(że)}
smucić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
smucić się: _: : imperf: subj{np(str)} + {or}
smucić: _: : imperf: subj{cp(gdy)} + {np(str)}
smucić: _: : imperf: subj{cp(int)} + {np(str)}
smucić: _: : imperf: subj{cp(jak)} + {np(str)}
smucić: _: : imperf: subj{cp(kiedy)} + {np(str)}
smucić: _: : imperf: subj{cp(że)} + {np(str)}
smucić: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
smucić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
smucić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
smucić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
smutek: : : : {np(gen)}
smutek: : : : {possp} + {comprepnp(z powodu)}
smutek: : : : {possp} + {cp(że)}
smutek: : : : {possp} + {prepnp(po,loc)}
smutek: : : : {possp} + {prepnp(przez,acc)}
snuć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
snuć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
snuć się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
snuć się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
snuć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
solić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
solidarny: : : : {comprepnp(w stosunku do)}
solidarny: : : : {prepnp(dla,gen)}
solidarny: : : : {prepnp(między,inst)}
solidarny: : : : {prepnp(w,loc); prepncp(w,loc,że)} + {prepnp(z,inst)}
solidarny: : : : {prepnp(wobec,gen)}
solidarny: : : : {prepnp(względem,gen)}
solidaryzować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
spacerować: _: : imperf: subj{np(str)} + {xp(perl)}
spaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
spać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
spać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
spać: _: : imperf: subj{np(str)} + {xp(locat)}
spadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spadać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
spadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
spadać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
spadać: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
spajać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spajać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
spajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spakować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
spakować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
spakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
spakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
spakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
spalać się: _: : imperf: subj{np(str)} + {advp(misc)}
spalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spalać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
spalać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
spalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
spalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
spalać: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'panewka',natr)}
spalić się: _: : perf: subj{np(str)} + {advp(misc)}
spalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spalić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
spalić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
spalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
spalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
spalić: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'panewka',natr)}
spanikować: _: : perf: subj{np(str)} + {cp(że)}
spanikować: _: : perf: subj{np(str)} + {or}
sparaliżować: _: : perf: {np(str)}
sparaliżować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
sparaliżować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
sparzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
sparzyć się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
sparzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
sparzyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
sparzyć: _: : perf: subj{E} + {np(str)}
sparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
sparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
spaść się: _: : perf: subj{np(str)} + {np(inst)}
spaść się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
spaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spaść: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
spaść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spaść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
spaść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
spaść: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
specjalizować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
spekulować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
spekulować: _: : imperf: subj{np(str)} + {cp(int)}
spekulować: _: : imperf: subj{np(str)} + {cp(że)}
spekulować: _: : imperf: subj{np(str)} + {np(inst)}
spekulować: _: : imperf: subj{np(str)} + {or}
spekulować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
spekulować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
spełniać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
spełniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
spełniać: _: : imperf: subj{np(str)} + obj{np(str)}
spełnić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
spełnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
spełnić: _: : perf: subj{np(str)} + obj{np(str)}
spełzać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
spełzać: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'nic',natr)}
spełznąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
spełznąć: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'nic',natr)}
speszyć się: _: : perf: subj{np(str)} + {cp(int)}
speszyć się: _: : perf: subj{np(str)} + {cp(że)}
speszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
speszyć się: _: : perf: subj{np(str)} + {or}
speszyć: _: : perf: subj{cp(gdy)} + {np(str)}
speszyć: _: : perf: subj{cp(int)} + {np(str)}
speszyć: _: : perf: subj{cp(jak)} + {np(str)}
speszyć: _: : perf: subj{cp(jeśli)} + {np(str)}
speszyć: _: : perf: subj{cp(kiedy)} + {np(str)}
speszyć: _: : perf: subj{cp(że)} + {np(str)}
speszyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
speszyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
spędzać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'oko',natr)}
spędzać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'powieka',natr)}
spędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
spędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,inst)}
spędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
spędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
spędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
spędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
spędzić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'oko',natr)}
spędzić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'powieka',natr)}
spędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
spędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,inst)}
spędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
spędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
spędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
spędzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spędzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
spękać: _: : perf: subj{np(str)} + {cp(że)}
spękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spękać: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
spętać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
spętać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spętać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spiąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
spiąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
spiąć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
spiąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
spiąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
spiąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
spiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
spiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
spić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
spić się: _: : perf: subj{np(str)} + {np(inst)}
spić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spienić się: _: : perf: subj{np(str)} + {np(dat)}
spienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
spienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
spienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
spienić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
spienić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spierać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
spierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
spierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
spierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
spierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
spierdalać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
spierdalać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
spierdalać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
spierdalać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
spierzchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spieszyć się: _: : imperf: {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
spieszyć się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
spieszyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
spieszyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spieszyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
spieszyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
spieszyć: _: : perf: subj{np(str)} + obj{np(str)}
spieszyć: _: : perf: subj{np(str)} + {refl}
spieszyć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
spieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
spieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
spieszyć: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(ku,dat); prepnp(na,acc); xp(adl)} + {xp(perl)}
spijać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
spijać się: _: : imperf: subj{np(str)} + {np(inst)}
spijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
spinać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
spinać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
spinać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
spinać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
spinać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
spinać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
spinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
spinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
spisać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
spisać: _: : perf: subj{np(str)} + obj{cp(int)}
spisać: _: : perf: subj{np(str)} + obj{cp(że)}
spisać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
spisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
spisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
spisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
spisać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
spisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
spisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
spisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
spisywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
spisywać: _: : imperf: subj{np(str)} + obj{cp(int)}
spisywać: _: : imperf: subj{np(str)} + obj{cp(że)}
spisywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
spisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
spisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
spisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
spisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
spisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
spisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
spisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
splamić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
splamić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
splamić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
splatać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
splatać się: _: : imperf: subj{np(str)} + {np(inst)}
splatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
splatać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
splądrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
splątać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
splątać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
splątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
splątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spleść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spleść się: _: : perf: subj{np(str)} + {np(inst)}
spleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spleść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
splunąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
spluwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
spłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spłaszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
spłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
spłaszczyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
spłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
spławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
spławić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
spłodzić się: _: : perf: subj{np(str)}
spłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
spłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
spłodzić: _: : perf: subj{np(str)} + {refl}
spłonąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
spłoszyć się: _: : perf: subj{np(str)} + {cp(że)}
spłoszyć się: _: : perf: subj{np(str)} + {np(inst)}
spłoszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spłycać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
spłycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
spłycić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
spłycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
spłynąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
spłynąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
spłynąć: _: : perf: subj{np(str)} + {prepnp(po,loc)}
spłynąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
spływać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
spływać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
spływać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
spływać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
spocić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spocić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spocząć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
spocząć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
spocząć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
spocząć: _: : perf: subj{np(str)} + {xp(dur)}
spoczywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
spoczywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
spoczywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
spodobać się: _: : perf: {np(dat)} + {xp(locat)}
spodobać się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
spodobać się: _: : perf: subj{cp(gdy)} + {np(dat)}
spodobać się: _: : perf: subj{cp(jak)} + {np(dat)}
spodobać się: _: : perf: subj{cp(kiedy)} + {np(dat)}
spodobać się: _: : perf: subj{cp(że)} + {np(dat)}
spodobać się: _: : perf: subj{np(str); ncp(str,jak); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
spodziewać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
spodziewać się: _: : imperf: subj{np(str)} + {np(gen); cp(że); cp(żeby2); ncp(gen,że); ncp(gen,żeby2)} + {prepnp(od,gen)}
spodziewać się: _: : imperf: subj{np(str)} + {np(gen); cp(że); cp(żeby2); ncp(gen,że); ncp(gen,żeby2)} + {prepnp(po,loc)}
spoglądać się: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spoglądać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spoglądać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
spoglądać: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spoglądać: _: : imperf: subj{np(str)} + {cp(int)}
spoglądać: _: : imperf: subj{np(str)} + {cp(że)}
spoglądać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spoglądać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
spoglądać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
spoglądać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
spoglądnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
spoić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spoić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
spoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spojrzeć się: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spojrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spojrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
spojrzeć: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spojrzeć: _: : perf: subj{np(str)} + {cp(int)}
spojrzeć: _: : perf: subj{np(str)} + {cp(że)}
spojrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spojrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
spojrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
spojrzeć: _: : perf: subj{np(str)} + {prepnp(po,loc)}
spojrzeć: _: : perf: subj{np(str)} + {xp(adl)}
spokrewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
spokrewnić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
sponiewierać się: _: : perf: subj{np(str)}
sponiewierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
spopularyzować się: _: : perf: subj{np(str)} + {xp(locat)}
spopularyzować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
sportretować się: _: : perf: subj{np(str)}
sportretować: _: : perf: subj{np(str)} + obj{np(str)}
sportretować: _: : perf: subj{np(str)} + {refl}
sporządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
sporządzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
sposobić się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
sposobić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
sposobić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
sposobić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
sposób: neg: : imperf: {cp(żeby)}
sposób: neg: : imperf: {infp(_)}
spostrzec się: _: : perf: subj{np(str)} + {cp(gdy)}
spostrzec się: _: : perf: subj{np(str)} + {cp(int)}
spostrzec się: _: : perf: subj{np(str)} + {cp(jak)}
spostrzec się: _: : perf: subj{np(str)} + {cp(kiedy)}
spostrzec się: _: : perf: subj{np(str)} + {cp(że)}
spostrzec: _: : perf: subj{np(str)} + {cp(gdy)}
spostrzec: _: : perf: subj{np(str)} + {cp(int)}
spostrzec: _: : perf: subj{np(str)} + {cp(jak)}
spostrzec: _: : perf: subj{np(str)} + {cp(kiedy)}
spostrzec: _: : perf: subj{np(str)} + {cp(że)}
spostrzec: _: : perf: subj{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
spostrzegać się: _: : imperf: subj{np(str)} + {cp(gdy)}
spostrzegać się: _: : imperf: subj{np(str)} + {cp(int)}
spostrzegać się: _: : imperf: subj{np(str)} + {cp(jak)}
spostrzegać się: _: : imperf: subj{np(str)} + {cp(kiedy)}
spostrzegać się: _: : imperf: subj{np(str)} + {cp(że)}
spostrzegać: _: : imperf: subj{np(str)} + {cp(gdy)}
spostrzegać: _: : imperf: subj{np(str)} + {cp(int)}
spostrzegać: _: : imperf: subj{np(str)} + {cp(jak)}
spostrzegać: _: : imperf: subj{np(str)} + {cp(kiedy)}
spostrzegać: _: : imperf: subj{np(str)} + {cp(że)}
spostrzegać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
spotęgować się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
spotęgować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
spotęgować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
spotęgować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spotkać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
spotkać: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
spotkać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spotykać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
spotykać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
spotykać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spowalniać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
spowalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
spoważnieć: _: : perf: subj{np(str)} + {np(dat)}
spowiadać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
spowiadać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
spowiadać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
spowiadać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowiadać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
spowiadać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
spowiadać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
spowiadać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowiadać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowić się: _: : perf: subj{np(str)} + {np(inst)}
spowić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
spowić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
spowić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
spowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spowić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
spowijać się: _: : imperf: subj{np(str)} + {np(inst)}
spowijać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
spowijać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
spowijać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
spowijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spowijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spowijać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
spowinowacić się: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)}
spowodować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)}
spowodować: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(inst); ncp(inst,że)}
spowolnić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
spowolnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
spozierać: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spozierać: _: : imperf: subj{np(str)} + {cp(jak)}
spozierać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spozierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
spozierać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,jak)}
spozierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
spozierać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
spozierać: _: : imperf: subj{np(str)} + {xp(adl)}
spożyć: _: : perf: subj{np(str)} + obj{np(str)}
spożytkować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
spożytkować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
spożytkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
spożytkować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spożywać: _: : imperf: subj{np(str)} + obj{np(str)}
spółkować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
spór: : : : {cp(że)}
spór: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)} + {prepnp(z,inst)}
spór: : : : {possp} + {prepnp(o,acc); comprepnp(w sprawie); prepncp(o,acc,int)} + {prepnp(z,inst)}
spór: : : : {possp} + {prepnp(wokół,gen)} + {prepnp(z,inst)}
spór: : : : {possp} + {prepnp(z,inst)} + {comprepnp(na temat)}
spór: : : : {possp} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
spór: : : : {possp} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
spór: : : : {possp} + {prepnp(z,inst)} + {comprepnp(z powodu)}
spór: : : : {possp} + {prepnp(z,inst)} + {preplexnp(na,loc,sg,'tło',atr)}
spór: : : : {possp} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'zakres',atr)}
spór: : : : {possp} + {prepnp(z,inst)} + {preplexnp(z,gen,sg,'zakres',atr)}
spór: : : : {preplexnp(z,gen,sg,'dziedzina',atr)}
spór: : : : {prepnp(co do,gen); prepncp(co do,gen,int)} + {prepnp(między,inst)}
spór: : : : {prepnp(między,inst)} + {comprepnp(na temat)}
spór: : : : {prepnp(między,inst)} + {comprepnp(w kwestii)}
spór: : : : {prepnp(między,inst)} + {comprepnp(w sprawie)}
spór: : : : {prepnp(między,inst)} + {comprepnp(z powodu)}
spór: : : : {prepnp(między,inst)} + {preplexnp(na,loc,sg,'tło',atr)}
spór: : : : {prepnp(między,inst)} + {preplexnp(w,loc,sg,'zakres',atr)}
spór: : : : {prepnp(między,inst)} + {preplexnp(z,gen,sg,'zakres',atr)}
spór: : : : {prepnp(między,inst)} + {prepnp(wokół,gen)}
spór: : : : {prepnp(między,inst); xp(locat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
spóźniać się: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepnp(na,acc)}
spóźniać się: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
spóźniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(o,acc)}
spóźniać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
spóźnić się: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepnp(na,acc)}
spóźnić się: _: : perf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
spóźnić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(o,acc)}
spóźnić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
sprawdzać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
sprawdzać się: _: : imperf: subj{cp(że)}
sprawdzać się: _: : imperf: subj{ncp(str,że)}
sprawdzać się: _: : imperf: subj{np(str)} + {np(dat)}
sprawdzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
sprawdzać się: _: : imperf: subj{np(str)} + {xp(locat)}
sprawdzać: _: : imperf: subj{np(str)} + obj{cp(że)}
sprawdzać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
sprawdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprawdzić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
sprawdzić się: _: : perf: subj{cp(że)}
sprawdzić się: _: : perf: subj{ncp(str,że)}
sprawdzić się: _: : perf: subj{np(str)} + {np(dat)}
sprawdzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
sprawdzić się: _: : perf: subj{np(str)} + {xp(locat)}
sprawdzić: _: : perf: subj{np(str)} + obj{cp(że)}
sprawdzić: _: : perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
sprawdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprawiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
sprawiać: _: : imperf: subj{np(str)} + {cp(żeby)}
sprawiać: _: : imperf: subj{np(str); cp(że); ncp(str,że)} + obj{np(str)} + {np(dat)}
sprawiać: _: : imperf: subj{np(str); ncp(str,że)} + {cp(że); ncp(str,że)}
sprawiać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że); ncp(str,że)}
sprawiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
sprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
sprawić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
sprawić: _: : perf: subj{np(str)} + {cp(żeby)}
sprawić: _: : perf: subj{np(str); cp(że); ncp(str,że)} + obj{np(str)} + {np(dat)}
sprawić: _: : perf: subj{np(str); ncp(str,że)} + {cp(że); ncp(str,że)}
sprawić: _: : perf: subj{np(str)} + {np(inst)} + {cp(że); ncp(str,że)}
sprawić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
sprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
sprawować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
sprawować: _: : imperf: subj{np(str)} + obj{np(str)}
sprecyzować się: _: : perf: subj{np(str)}
sprecyzować: _: : perf: subj{np(str)} + obj{cp(int)}
sprecyzować: _: : perf: subj{np(str)} + obj{cp(że)}
sprecyzować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
sprecyzować: _: : perf: subj{np(str)} + {or}
spreparować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
spreparować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
spreparować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
spreparować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sprezentować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sprężać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
sprężać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
sprężać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
sprężać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
sprężać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
sprężyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
sprężyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
sprężyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
sprężyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
sprężyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
sprostać: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
sprostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprostować się: _: : perf: subj{np(str)} + {np(dat)}
sprostować: _: : perf: subj{np(str)} + {cp(że)}
sprostować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
sprostować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprostować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
sproszkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {prepnp(na,acc)}
sproszkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
sprowadzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
sprowadzać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
sprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
sprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
sprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
sprowadzić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
sprowadzić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
sprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
sprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
sprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
sprowokować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
sprowokować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {cp(żeby)}
sprowokować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
spróbować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
spróbować: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
spróbować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'siła',batr)}
spróbować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,sg,'szczęście',atr)}
spróbować: _: : perf: subj{np(str)} + {cp(czy)}
spróbować: _: : perf: subj{np(str)} + {np(gen)}
spróbować: _: : perf: subj{np(str)} + {np(str)}
spróbować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,pl,'siła',batr)}
spróbować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,sg,'szczęście',atr)}
spróbować: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(gen,pl,'siła',batr)}
spróbować: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(gen,sg,'szczęście',atr)}
spróchnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spróchnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spryskać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
spryskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spryskiwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
spryskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprywatyzować się: _: : perf: subj{np(str)}
sprywatyzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sprząc się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sprząc się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sprząc: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sprząc: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sprzątać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
sprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
sprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
sprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
sprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
sprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sprzeciw: : : : {possp} + {comprepnp(na temat)}
sprzeciw: : : : {possp} + {comprepnp(w kwestii)}
sprzeciw: : : : {possp} + {comprepnp(w sprawie)}
sprzeciw: : : : {possp} + {cp(jakoby)}
sprzeciw: : : : {possp} + {cp(że)}
sprzeciw: : : : {possp} + {cp(żeby)}
sprzeciw: : : : {possp} + {or}
sprzeciw: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że); prepncp(co do,gen,żeby)}
sprzeciw: : : : {possp} + {prepnp(dla,gen); prepncp(dla,gen,że)}
sprzeciw: : : : {possp} + {prepnp(do,gen)}
sprzeciw: : : : {possp} + {prepnp(od,gen)}
sprzeciw: : : : {possp} + {prepnp(wobec,gen); comprepnp(w stosunku do); prepncp(wobec,gen,int); prepncp(wobec,gen,że); prepncp(wobec,gen,żeby)}
sprzeciw: : : : {possp} + {prepnp(względem,gen); prepncp(względem,gen,int); prepncp(względem,gen,że); prepncp(względem,gen,żeby)}
sprzeciwiać się: _: : imperf: subj{np(str)} + {cp(że)}
sprzeciwiać się: _: : imperf: subj{np(str)} + {cp(żeby)}
sprzeciwiać się: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)} + {or}
sprzeciwiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprzeciwić się: _: : perf: subj{np(str)} + {cp(że)}
sprzeciwić się: _: : perf: subj{np(str)} + {cp(żeby)}
sprzeciwić się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)} + {or}
sprzeciwić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
sprzeczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
sprzeniewierzać się: _: : imperf: subj{np(str)} + {np(dat)}
sprzeniewierzać: _: : imperf: subj{np(str)} + obj{np(str)}
sprzeniewierzyć się: _: : perf: subj{np(str)} + {np(dat)}
sprzeniewierzyć: _: : perf: subj{np(str)} + obj{np(str)}
sprzęgać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sprzęgać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sprzęgać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sprzęgać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sprzęgnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sprzęgnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
sprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sprzyjać: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
sprzyjać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
spuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spustoszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
spuszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
spuszczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
spuszczać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
spuszczać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
spuszczać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
spuszczać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
spuszczać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
spuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
spuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
spuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spuścić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuścić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
spuścić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
spuścić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
spuścić się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
spuścić się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
spuścić się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
spuścić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
spuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
spuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
spuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
spuścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
spychać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spytać się: _: : perf: subj{np(str)} + {np(gen)} + {or}
spytać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
spytać: _: : perf: subj{np(str)} + obj{np(gen)} + {or}
spytać: _: : perf: subj{np(str)} + obj{np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
spytać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
spytać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
spytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
spytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
srać się: _: : imperf: subj{np(str)} + {cp(że)}
srać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
srać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
srać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
srać: _: : imperf: subj{np(str)} + {np(inst)}
srać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
ssać: _: : imperf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
ssać: _: : imperf: {np(str)} + {prepnp(z,gen)} + {xp(locat)}
ssać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ssać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
stabilizować się: _: : imperf: subj{np(str)}
stabilizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
stacjonować: _: : imperf: subj{np(str)} + {xp(locat)}
staczać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
staczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
staczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
stać się: _: : perf: {cp(że)} + {advp(misc)}
stać się: _: : perf: {np(dat)} + {advp(misc)}
stać się: _: : perf: subj,controller{cp(int)} + controllee{adjp(pred)}
stać się: _: : perf: subj,controller{cp(int)} + controllee{np(inst)}
stać się: _: : perf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
stać się: _: : perf: subj,controller{cp(żeby)} + controllee{np(inst)}
stać się: _: : perf: subj,controller{cp(że)} + controllee{adjp(pred)}
stać się: _: : perf: subj,controller{cp(że)} + controllee{np(inst)}
stać się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)} + controllee{prepadjp(z,gen)} + {np(dat)}
stać się: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)} + {prepnp(z,gen)}
stać się: _: : perf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
stać się: _: : perf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
stać się: _: : perf: subj{cp(że)}
stać się: _: : perf: subj{nonch} + {np(dat)} + {prepnp(z,inst)}
stać się: _: : perf: subj{np(str)} + {np(dat)}
stać: _: : imperf: {np(dat)} + {np(gen)}
stać: _: : imperf: {np(str)} + {cp(żeby)}
stać: _: : imperf: {np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
stać: _: : imperf: {prepnp(o,loc); prepncp(o,loc,że)} + {xp(locat)}
stać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
stać: _: : imperf: subj{cp(żeby)} + {xp(locat)}
stać: _: : imperf: subj{cp(że)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: _: : imperf: subj{cp(że)} + {xp(locat)}
stać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'ość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: _: : imperf: subj{np(str); ncp(str,że)} + {np(gen); ncp(gen,że)} + {preplexnp(u,gen,pl,'podstawa',natr)}
stać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'droga',natr)}
stać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'zawada',natr)}
stać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
stać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)} + {fixed('dęba')}
stać: _: : imperf: subj{np(str)} + {np(inst)}
stać: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',ratr)}
stać: _: : imperf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',ratr)}
stać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(w,loc,sg,'sprzeczność',atr)}
stać: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
stać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
stać: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(locat)}
stać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {lexnp(inst,sg,'mur',natr)}
stać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
stać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,sg,'otwór',natr)}
stać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
stać: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
stać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,że); prepncp(za,inst,żeby)}
stać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)} + {lexnp(inst,sg,'mur',natr)}
stać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {advp(misc)}
stać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {preplexnp(w,loc,sg,'sprzeczność',atr)}
stanieć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
stanowić: _: : imperf: subj{cp(że)} + {np(str)}
stanowić: _: : imperf: subj{ncp(str,że)} + {prepnp(o,loc)}
stanowić: _: : imperf: subj{np(str)} + {cp(że)}
stanowić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
stanowić: _: : imperf: subj{np(str)} + obj{np(str)}
stanowić: _: : imperf: subj{np(str)} + {prepncp(o,loc,int)}
stanowić: _: : imperf: subj{np(str)} + {prepncp(o,loc,że)}
stanowić: _: : imperf: subj{np(str)} + {prepncp(o,loc,żeby2)}
stanowić: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
stapiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
stapiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
stapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
starać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby); infp(_)}
starczać: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
starczać: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
starczać: _: : imperf: {np(gen)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
starczać: _: : imperf: subj,controller{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controllee{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczać: _: : imperf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczać: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczać: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
starczać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
starczać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)}
starczać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
starczać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
starczyć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
starczyć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
starczyć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
starczyć: _: : perf: {np(gen)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
starczyć: _: : perf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: _: : perf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
starczyć: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
starczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)}
starczyć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
starczyć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
startować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
startować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
startować: _: : imperf: subj{np(str)} + {xp(abl)}
statystować: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
statystować: _: : imperf: subj{np(str)} + {xp(locat)}
stawać się: _: : imperf: {cp(że)} + {advp(misc)}
stawać się: _: : imperf: {np(dat)} + {advp(misc)}
stawać się: _: : imperf: subj,controller{cp(int)} + controllee{adjp(pred)}
stawać się: _: : imperf: subj,controller{cp(int)} + controllee{np(inst)}
stawać się: _: : imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
stawać się: _: : imperf: subj,controller{cp(żeby)} + controllee{np(inst)}
stawać się: _: : imperf: subj,controller{cp(że)} + controllee{adjp(pred)}
stawać się: _: : imperf: subj,controller{cp(że)} + controllee{np(inst)}
stawać się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)} + controllee{prepadjp(z,gen)} + {np(dat)}
stawać się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)} + {prepnp(z,gen)}
stawać się: _: : imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
stawać się: _: : imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
stawać się: _: : imperf: subj{cp(że)}
stawać się: _: : imperf: subj{nonch} + {np(dat)} + {prepnp(z,inst)}
stawać się: _: : imperf: subj{np(str)} + {np(dat)}
stawać: _: : imperf: {np(dat)} + {np(gen)}
stawać: _: : imperf: {prepadjp(na,loc)}
stawać: _: : imperf: {prepnp(na,loc); prepncp(na,loc,że); prepncp(na,loc,żeby)}
stawać: _: : imperf: subj{cp(że)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stawać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stawać: _: : imperf: subj{lexnp(str,pl,'oko',natr)} + {np(dat)} + {preplexnp(w,acc,sg,'słup',natr)}
stawać: _: : imperf: subj{lexnp(str,pl,'świeczka',natr)} + {np(dat)} + {preplexnp(w,loc,pl,'oko',natr)}
stawać: _: : imperf: subj{lexnp(str,sg,'język',natr)} + {np(dat)} + {lexnp(inst,sg,'kołek',natr)}
stawać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'słupek',natr)}
stawać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'sztorc',natr)}
stawać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stawać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stawać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'ość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stawać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stawać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
stawać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'droga',natr)}
stawać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'zawada',natr)}
stawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
stawać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
stawać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)} + {fixed('dęba')}
stawać: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',ratr)}
stawać: _: : imperf: subj{np(str)} + {preplexnp(w,acc,pl,'szranki',atr)}
stawać: _: : imperf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',ratr)}
stawać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
stawać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(w,loc,sg,'sprzeczność',atr)}
stawać: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
stawać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {lexnp(inst,sg,'mur',natr)}
stawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,sg,'otwór',natr)}
stawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
stawać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
stawać: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
stawać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)} + {lexnp(inst,sg,'mur',natr)}
stawać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {preplexnp(w,loc,sg,'sprzeczność',atr)}
stawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'kant',natr)}
stawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
stawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(inst,sg,'sztorc',natr)}
stawiać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
stawiać się: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
stawiać się: _: : imperf: subj{np(str)} + {xp(adl)}
stawiać się: _: : imperf: subj{np(str)} + {xp(locat)}
stawiać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
stawiać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'czoło',natr)}
stawiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {cp(że)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {prepnp(za,acc)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,sg,'pręgierz',ratr)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',ratr)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
stawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
stawiać: _: : imperf: subj{np(str)} + {prepadjp(na,loc)}
stawiać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
stawiać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
stawiać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
stąpać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
stąpać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
stąpać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
stąpać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
stąpnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
stąpnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
stąpnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
stąpnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
stemplować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
stemplować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sterczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
sterczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
sterować: _: : imperf: subj{np(str)} + obj{np(inst); ncp(inst,int); ncp(inst,żeby)}
sterować: _: : imperf: subj{np(str)} + obj{np(inst)} + {np(inst)}
sterować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
sterroryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
stękać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
stękać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
stękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
stękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
stękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
stękać: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
stękać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
stęknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
stęknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
stęknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
stęknąć: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
stęknąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
stłuc się: _: : perf: subj{np(str)} + {np(inst)}
stłuc się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
stłuc: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('na kwaśne jabłko')}
stłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
stłuc: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'miazga',atr)}
stłumić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
stoczyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
stoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
stoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
stonować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
stonować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
stopić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
stopić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
stopić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
stopić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
stopnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
stopnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
stopnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
stopnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
stosować się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
stosować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
stosować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
stosować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
stowarzyszać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
stowarzyszać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
stowarzyszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
stowarzyszyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
stowarzyszyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
stowarzyszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
strach: : : : {fixed('blady')}
strach: : : : {np(gen)} + {possp}
strach: : : : {possp} + {comprepnp(w stosunku do)}
strach: : : : {possp} + {comprepnp(z powodu)}
strach: : : : {possp} + {cp(gdy)}
strach: : : : {possp} + {cp(int)}
strach: : : : {possp} + {cp(jakoby)}
strach: : : : {possp} + {cp(kiedy)}
strach: : : : {possp} + {cp(że)}
strach: : : : {possp} + {cp(żeby)}
strach: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
strach: : : : {possp} + {prepnp(o,acc); prepnp(przed,inst); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
strach: : : : {possp} + {prepnp(wobec,gen)}
strach: : : : {possp} + {prepnp(względem,gen)}
strach: : : : {preplexnp(na,acc,pl,'wróbel',natr)}
stracić: _: : perf: subj{np(str)} + {lexnp(str,sg,'grunt',natr)} + {preplexnp(pod,inst,pl,'noga',natr)}
stracić: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,pl,'oko',natr)}
stracić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
stracić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
stracić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
stracić: _: : perf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',ratr)}
stracić: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,sg,'serce',natr)}
stracić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,sg,'serce',natr)}
stracić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {nonch}
strajkować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że)}
straszyć: _: : imperf: {np(inst)}
straszyć: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
straszyć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
straszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
straszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); cp(że); ncp(inst,że)}
straszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
straszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
straszyć: _: : imperf: {xp(locat)}
strata: : : : {np(gen)} + {possp} + {comprepnp(na rzecz)}
strata: : : : {np(gen)} + {prepnp(dla,gen)}
strata: : : : {possp} + {comprepnp(z powodu)}
strata: : : : {possp} + {prepnp(do,gen)}
strata: : : : {possp} + {prepnp(na,loc)}
strata: : : : {possp} + {prepnp(po,loc)}
strata: : : : {possp} + {prepnp(w,loc)}
strata: : : : {possp} + {prepnp(z,gen)}
strategia: : : : {np(gen)} + {possp}
strategia: : : : {possp} + {comprepnp(na rzecz)}
strategia: : : : {possp} + {comprepnp(na temat)}
strategia: : : : {possp} + {comprepnp(w kwestii); comprepnp(w sprawie)}
strategia: : : : {possp} + {comprepnp(w stosunku do)}
strategia: : : : {possp} + {cp(żeby)}
strategia: : : : {possp} + {prepnp(co do,gen)}
strategia: : : : {possp} + {prepnp(dla,gen)}
strategia: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,żeby)}
strategia: : : : {possp} + {prepnp(o,loc)}
strategia: : : : {possp} + {prepnp(przeciw,dat)}
strategia: : : : {possp} + {prepnp(wobec,gen)}
strategia: : : : {possp} + {prepnp(względem,gen)}
stratować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
strącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
strącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stresować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
stresować się: _: : imperf: subj{np(str)} + {cp(int)}
stresować się: _: : imperf: subj{np(str)} + {cp(że)}
stresować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
stresować się: _: : imperf: subj{np(str)} + {or}
stresować: _: : imperf: subj{cp(gdy)} + {np(str)}
stresować: _: : imperf: subj{cp(int)} + {np(str)}
stresować: _: : imperf: subj{cp(jak)} + {np(str)}
stresować: _: : imperf: subj{cp(jeśli)} + {np(str)}
stresować: _: : imperf: subj{cp(kiedy)} + {np(str)}
stresować: _: : imperf: subj{cp(że)} + {np(str)}
stresować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
stresować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
streszczać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
streszczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
streszczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
streszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
streszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
streszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
streszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
streścić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
streścić się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
streścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
streścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
streścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
streścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
strofować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
strofować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
strofować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
strofować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
strojny: : : : {np(inst)}
strojny: : : : {prepnp(w,acc)}
stronić: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
stropić się: _: : perf: subj{np(str)} + {cp(że)}
stropić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
stropić się: _: : perf: subj{np(str)} + {or}
stropić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
stropić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
stroszyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
stroszyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
stroszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
stróżować: _: : imperf: subj{np(str)} + {xp(locat)}
struć się: _: : perf: subj{np(str)} + {np(inst)}
struć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
strugać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(z,gen)}
strugać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
strugać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
strzaskać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
strzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
strzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
strzec się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
strzec się: _: : imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
strzec: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
strzec: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(przed,inst)}
strzelać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
strzelać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
strzelać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
strzelać: _: : imperf: {np(dat)} + {prepnp(w,loc)}
strzelać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
strzelać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
strzelać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
strzelać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
strzelać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
strzelać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
strzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
strzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
strzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
strzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
strzelać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
strzelać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
strzelić: _: : perf: {np(dat)} + {prepnp(w,loc)}
strzelić: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
strzelić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
strzelić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
strzelić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
strzelić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
strzelić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
strzelić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
strzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
strzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
strzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
strzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
strzelić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
strzelić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
strzepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strzepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strzepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strzępić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
strzępić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
strzępić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
strzępić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
strzępić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
strzępić się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
strzępić: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'język',natr)}
strzępić: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'język',natr)}
strzępić: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'język',natr)}
strzępić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
strzępić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
strzępić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
strzępić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
strzępić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
strzępić: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'język',natr)}
strzyc się: _: : imperf: subj{np(str)} + {xp(locat)} + {advp(misc)}
strzyc: _: : imperf: subj{np(str)} + {lexnp(inst,pl,'ucho',natr)}
strzyc: _: : imperf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
strzyc: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
studiować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
studiować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
studiować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
studzić się: _: : imperf: subj{np(str)} + {xp(locat)}
studzić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
studzić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
studzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
studzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
stukać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
stukać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
stukać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
stukać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
stukać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
stukać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
stukać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
stukać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
stuknąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
stuknąć: _: : perf: subj{np(str)} + {np(dat)}
stuknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
stuknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
stuknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
stuknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
stulać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
stulać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
stulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
stulać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
stulać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
stulić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
stulić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
stulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
stulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
stulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
stwarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
stwierdzać: _: : imperf: subj{np(str)} + {cp(int)}
stwierdzać: _: : imperf: subj{np(str)} + {cp(że)}
stwierdzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
stwierdzać: _: : imperf: subj{np(str)} + {or}
stwierdzić: _: : perf: subj{np(str)} + {cp(int)}
stwierdzić: _: : perf: subj{np(str)} + {cp(że)}
stwierdzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
stwierdzić: _: : perf: subj{np(str)} + {or}
stworzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
stworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
stworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
stylizować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
stylizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
stymulować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
subskrybować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
subskrybować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
subskrybować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
subsydiować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
subsydiować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
subtelnieć: _: : imperf: subj{np(str)} + {np(dat)}
sugerować się: _: : imperf: subj{np(str)} + {cp(że)}
sugerować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
sugerować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
sugerować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
sugerować: _: : imperf: subj{np(str)} + obj{cp(jakoby)} + {np(dat)} + {np(inst)}
sugerować: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {np(inst)}
sugerować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
sugerować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
sukces: : : : {possp} + {cp(że)}
sukces: : : : {possp} + {prepnp(w,loc); xp(locat)}
sukces: : : : {possp} + {prepnp(z,inst)}
sukces: : : : {prepnp(dla,gen)}
sumować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
sumować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
sumować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
sumować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
sumować: _: : imperf: subj{np(str)} + {cp(int)}
sumować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
sunąć się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
sunąć się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
sunąć się: _: : imperf: subj{np(str)} + {xp(perl)}
sunąć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
sunąć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
sunąć: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
sunąć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
sunąć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
sunąć: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
sunąć: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
sunąć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
surfować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
surfować: _: : imperf: subj{np(str)} + {xp(locat)}
suszyć się: _: : imperf: subj{np(str)} + {xp(locat)}
suszyć: _: : imperf: {np(str)}
suszyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {lexnp(str,sg,'głowa',natr)}
suszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {lexnp(str,sg,'głowa',natr)}
suszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
swatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
swatać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
swędzić: _: : imperf: {np(str)} + {xp(locat)}
swędzić: _: : imperf: subj{cp(żeby)} + {np(str)}
swędzić: _: : imperf: subj{lexnp(str,sg,'ręka',natr)} + {np(str)} + {prepnp(na,acc)}
swędzić: _: : imperf: subj{np(str)} + {np(str)}
swędzić: _: : imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
swędzieć: _: : imperf: {np(str)} + {xp(locat)}
swędzieć: _: : imperf: subj{cp(żeby)} + {np(str)}
swędzieć: _: : imperf: subj{lexnp(str,sg,'ręka',natr)} + {np(str)} + {prepnp(na,acc)}
swędzieć: _: : imperf: subj{np(str)} + {np(str)}
swędzieć: _: : imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
swoboda: : : : {np(gen)} + {possp}
swoboda: : : : {possp} + {comprepnp(w stosunku do)}
swoboda: : : : {possp} + {prepnp(do,gen)}
swoboda: : : : {possp} + {prepnp(od,gen)}
swoboda: : : : {possp} + {prepnp(w,loc); prepncp(w,loc,int)}
swoboda: : : : {possp} + {prepnp(wobec,gen)}
swoboda: : : : {possp} + {prepnp(względem,gen)}
sycić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
sycić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
syczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
syczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
syczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
syczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
syczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
syczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
syczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
syczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
sygnalizować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
sygnalizować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
sygnalizować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)}
sygnalizować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
sygnalizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
sykać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
sykać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
sykać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
sykać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
sykać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
sykać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
sykać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
sykać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
syknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
syknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
syknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
syknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
syknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
syknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
syknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
syknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
symbolizować: _: : imperf: subj{np(str)} + {cp(int)}
symbolizować: _: : imperf: subj{np(str)} + {cp(że)}
symbolizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
sympatia: : : : {possp} + {comprepnp(w kwestii)}
sympatia: : : : {possp} + {comprepnp(w stosunku do)}
sympatia: : : : {possp} + {prepnp(co do,gen)}
sympatia: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen)}
sympatia: : : : {possp} + {prepnp(ku,dat)}
sympatia: : : : {possp} + {prepnp(wobec,gen)}
sympatia: : : : {possp} + {prepnp(względem,gen)}
sympatia: : : : {prepnp(między,inst)}
sympatyzować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sympatyzować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sypać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
sypać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
sypać: _: : imperf: {np(inst)}
sypać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
sypać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
sypać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
sypać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
sypać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
sypiać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
sypiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
sypiać: _: : imperf: subj{np(str)} + {xp(locat)}
sypnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
sypnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
sypnąć: _: : perf: {np(inst)}
sypnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
sypnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
sypnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
sypnąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
sypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
systematyzować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
systematyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sytuować się: _: : imperf: subj{np(str)} + {xp(locat)}
sytuować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
syty: : : : {np(gen)}
syty: : : : {np(inst); ncp(inst,że)}
syty: : : : {prepnp(od,gen)}
szabrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
szabrować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
szacować: _: : imperf: subj{np(str)} + {cp(int)}
szacować: _: : imperf: subj{np(str)} + {cp(że)}
szacować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
szacować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
szacować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szacować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szacunek: : : : {possp} + {comprepnp(na temat)}
szacunek: : : : {possp} + {comprepnp(w kwestii)}
szacunek: : : : {possp} + {comprepnp(w sprawie)}
szacunek: : : : {possp} + {cp(że)}
szacunek: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int)}
szacunek: : : : {possp} + {prepnp(dla,gen); prepnp(do,gen); prepnp(wobec,gen); comprepnp(w stosunku do); prepncp(dla,gen,żeby); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(wobec,gen,int); prepncp(wobec,gen,że)}
szacunek: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
szacunek: : : : {possp} + {prepnp(względem,gen); prepncp(względem,gen,że)}
szacunek: : : : {prepnp(dla,gen); prepnp(do,gen)} + {preplexnp(z,gen,sg,'strona',ratr)}
szacunek: : : : {prepnp(do,gen); preplexnp(z,gen,sg,'strona',ratr)}
szacunek: : : : {prepnp(między,inst)}
szafować: _: : imperf: subj{np(str)} + {np(inst)}
szafować: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
szafować: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(dla,gen)}
szaleć: _: : imperf: subj{np(str)} + {np(inst)}
szaleć: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
szaleć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
szaleć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
szaleć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
szaleć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
szaleć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
szaleć: _: : imperf: subj{np(str)} + {xp(locat)}
szamotać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
szamotać: _: : imperf: subj{np(str)} + obj{np(inst)}
szamotać: _: : imperf: subj{np(str)} + obj{np(str)}
szanować się: _: : imperf: subj{np(str)}
szanować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
szanować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
szanować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
szanować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
szanować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
szantażować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
szantażować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
szarogęsić się: _: : imperf: subj{np(str)} + {xp(locat)}
szarpać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
szarpać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
szarpać się: _: : imperf: subj{np(str)} + {xp(adl)}
szarpać: _: : imperf: {np(inst)} + {prepnp(po,loc)}
szarpać: _: : imperf: {np(inst)} + {xp(adl)}
szarpać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szarpać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
szarpać: _: : imperf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
szarpać: _: : imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
szarpać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
szarpać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
szarpać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
szarpać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
szarpać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
szarpnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
szarpnąć się: _: : perf: subj{np(str)} + {xp(adl)}
szarpnąć: _: : perf: {np(inst)} + {xp(adl)}
szarpnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szarpnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
szarpnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
szarpnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
szarpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
szarpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
szarpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
szczekać: _: : imperf: subj{np(str)} + {np(str)}
szczekać: _: : imperf: subj{np(str)} + {or}
szczekać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
szczekać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
szczekać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
szczekać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
szczekać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
szczepić się: _: : imperf: subj{np(str)} + {np(inst)}
szczepić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
szczepić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
szczepić się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
szczepić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
szczepić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szczepić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szczepić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
szczepić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
szczepić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
szczerzyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
szczerzyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
szczerzyć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
szczerzyć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
szczędzić się: neg: : imperf: subj{np(str)} + {prepnp(w,loc)}
szczędzić: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
szczędzić: neg: : imperf: subj{np(str)} + obj{np(gen)} + {cp(żeby)}
szczędzić: neg: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,że)} + {np(dat)}
szczędzić: neg: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(dla,gen); prepnp(na,acc); prepncp(na,acc,żeby)}
szczęście: : : : {possp} + {comprepnp(z powodu)}
szczęście: : : : {possp} + {cp(że)}
szczęście: : : : {possp} + {cp(żeby)}
szczęście: : : : {possp} + {cp(że)} + {preplexnp(w,loc,sg,'nieszczęście',natr)}
szczęście: : : : {possp} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
szczęście: : : : {possp} + {prepnp(w,loc); xp(locat)}
szczodry: : : : {comprepnp(w stosunku do)}
szczodry: : : : {np(inst)}
szczodry: : : : {prepnp(dla,gen)} + {prepnp(w,loc)}
szczodry: : : : {prepnp(wobec,gen)}
szczodry: : : : {prepnp(względem,gen)}
szczuć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
szczuć: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
szczuć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szczuć: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
szczuć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szczuć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
szczycić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
szczycić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
szczycić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
szczycić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
szczypać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
szczypać: _: : imperf: {np(str)} + {prepnp(w,acc)}
szczypać: _: : imperf: {np(str)} + {xp(locat)}
szczypać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
szczypać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
szczypać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
szczypać: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
szczypać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szczypać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szczypać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
szefować: _: : imperf: subj{np(str)} + {np(dat)}
szefować: _: : imperf: subj{np(str)} + {xp(locat)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
szepnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',natr)} + {or}
szepnąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
szepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
szepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
szepnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
szepnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szepnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szepnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
szeptać: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: : imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szeptać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: : imperf: subj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)} + {or}
szeptać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
szeptać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szeptać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szeptać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
szeptać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
szeptać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
szeptać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
szeptać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
szermować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
szermować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
szkalować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)}
szkalować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
szkalować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
szklić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
szklić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
szklić: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(str,pl,'oko',natr)}
szklić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szklić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
szkoda: _: : imperf: controller{np(dat)} + controllee{infp(_)}
szkoda: _: : imperf: {np(dat)} + {cp(gdy)}
szkoda: _: : imperf: {np(dat)} + {cp(jak)}
szkoda: _: : imperf: {np(dat)} + {cp(kiedy)}
szkoda: _: : imperf: {np(dat)} + {cp(że)}
szkoda: _: : imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
szkoda: _: : imperf: {np(dat)} + {np(gen); ncp(gen,że)}
szkoda: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(dla,gen)}
szkoda: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen)}
szkoda: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
szkodzić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat); ncp(dat,żeby)}
szkodzić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(na,acc)}
szkodzić: neg: : imperf: subj,controllee{infp(_)} + controller{np(dat)} + {nonch}
szkodzić: neg: : imperf: subj{cp(żeby)} + {np(dat)} + {nonch}
szkodzić: neg: : imperf: subj{cp(że)} + {np(dat)} + {nonch}
szkolić się: _: : imperf: subj{np(str)} + {cp(int)}
szkolić się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
szkolić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
szkolić się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
szkolić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
szkolić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
szkolić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
szkolić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
szkolić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szkolić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
szkolić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
szkolić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
szlifować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szokować: _: : imperf: subj{cp(gdy)} + {np(str)}
szokować: _: : imperf: subj{cp(int)} + {np(str)}
szokować: _: : imperf: subj{cp(jak)} + {np(str)}
szokować: _: : imperf: subj{cp(jeśli)} + {np(str)}
szokować: _: : imperf: subj{cp(kiedy)} + {np(str)}
szokować: _: : imperf: subj{cp(że)} + {np(str)}
szokować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
szokować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że); ncp(str,int)}
szorować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
szorować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szorować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
szorować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szorować: _: : imperf: subj{np(str)} + {xp(adl)}
szpecić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
szpecić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sztukować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szturchać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
szturchać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
szturchać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
szturchać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szturchać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
szturchać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
szturchnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
szturchnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
szturchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szturchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
szturchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
sztywnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
sztywnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
sztywnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sztywnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sztywnieć: _: : imperf: subj{np(str)} + {xp(locat)}
szukać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,sg,'szczęście',natr)}
szukać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(w,loc)}
szukać: _: : imperf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
szukać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
szumieć: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
szumieć: _: : imperf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
szumieć: _: : imperf: {prepnp(o,loc); prepncp(o,loc,że)} + {xp(locat)}
szumieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
szumieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
szumieć: _: : imperf: subj{np(str)} + {np(inst)}
szumieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
szumieć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
szumieć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
szurać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
szurać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szurać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
szurać: _: : imperf: subj{np(str)} + {xp(abl)}
szurać: _: : imperf: subj{np(str)} + {xp(adl)}
szurnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
szurnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szurnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(adl)} + {xp(perl)}
szurnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
szurnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
szurnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
szusować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
szusować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
szwankować: _: : imperf: subj{np(str)} + {np(dat)}
szwankować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
szwankować: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
szybować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
szybować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
szybować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
szyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
szyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
szyć: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
szyć: _: : imperf: subj{np(str)} + {xp(perl)}
szydzić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
szydzić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
szydzić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
szyfrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szykanować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
szykanować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
szykanować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szykanować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
szykować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
szykować się: _: : imperf: subj{np(str)} + {xp(locat)}
szykować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
szykować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szykować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szykować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
szykować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
ściąć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
ściąć się: _: : perf: subj{np(str)}
ściąć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
ściąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
ściąć: _: : perf: {np(str)} + {preplexnp(z,gen,pl,'noga',natr)}
ściąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ściąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'noga',natr)}
ściągać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
ściągać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(na,acc,sg,'głowa',natr)}
ściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
ściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ściągnąć się: _: : perf: subj{np(str)} + {np(dat)}
ściągnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(na,acc,sg,'głowa',natr)}
ściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
ściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ściec: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ściekać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ścielić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
ścielić się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
ścielić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
ścielić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ścielić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
ściemniać się: _: : imperf: subj{np(str)} + {np(dat)}
ściemniać się: _: : imperf: {xp(locat)}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(co do)}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
ściemniać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
ściemniać: _: : imperf: subj{np(str)} + {np(str)} + {comprepnp(co do)}
ściemniać: _: : imperf: subj{np(str)} + {np(str)} + {comprepnp(na temat)}
ściemniać: _: : imperf: subj{np(str)} + {np(str)} + {comprepnp(w kwestii)}
ściemniać: _: : imperf: subj{np(str)} + {np(str)} + {comprepnp(w sprawie)}
ściemniać: _: : imperf: subj{np(str)} + {np(str)} + {cp(int)}
ściemniać: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
ściemniać: _: : imperf: subj{np(str)} + {np(str)} + {or}
ściemniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ściemnić się: _: : perf: subj{np(str)} + {np(dat)}
ściemnić się: _: : perf: {xp(locat)}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(co do)}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {or}
ściemnić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
ściemnić: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(co do)}
ściemnić: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(na temat)}
ściemnić: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(w kwestii)}
ściemnić: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(w sprawie)}
ściemnić: _: : perf: subj{np(str)} + {np(str)} + {cp(int)}
ściemnić: _: : perf: subj{np(str)} + {np(str)} + {cp(że)}
ściemnić: _: : perf: subj{np(str)} + {np(str)} + {or}
ściemnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ścienić: _: : perf: subj{np(str)}
ścierać się: _: : imperf: subj{np(str)} + {np(dat)}
ścierać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
ścierać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
ścierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
ścierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ścierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ścierać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'proch',atr)}
ścierać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pył',atr)}
ścierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
ścierpnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ścierpnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ścigać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)} + {prepnp(z,inst)}
ścigać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ścigać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
ścinać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
ścinać się: _: : imperf: subj{np(str)}
ścinać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
ścinać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
ścinać: _: : imperf: {np(str)} + {preplexnp(z,gen,pl,'noga',natr)}
ścinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ścinać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'noga',natr)}
ściskać się: _: : imperf: subj{np(str)} + {np(dat)}
ściskać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ściskać: _: : imperf: {np(str)} + {xp(locat)}
ściskać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ściskać: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
ściskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ściskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ścisnąć się: _: : perf: subj{np(str)} + {np(dat)}
ścisnąć: _: : perf: {np(str)} + {xp(locat)}
ścisnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ścisnąć: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
ścisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ścisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ślad: : : : {adjp(agr); prepnp(po,loc)} + {xp(locat)}
ślad: : : : {cp(int)}
ślad: : : : {cp(że)}
ślad: : : : {cp(żeby2)}
ślad: : : : {np(gen); ncp(gen,int); ncp(gen,że)} + {xp(locat)}
ślad: : : : {possp} + {xp(locat)}
ślad: : : : {prepnp(od,gen)} + {xp(locat)}
śledzić: _: : imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)} + {np(inst)}
ślepnąć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
ślepnąć: _: : imperf: subj{np(str)} + {prepnp(wskutek,gen)}
ślepnąć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
ślęczeć: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
ślęczeć: _: : imperf: subj{np(str)} + {xp(locat)}
ślinić się: _: : imperf: subj{np(str)} + {np(inst)}
ślinić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
ślinić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
ślinić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ślinić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ślizgać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
ślizgać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
ślizgać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
ślizgać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
ślizgać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
ślubować: _: : imperf: subj,controller{np(str)} + obj,controllee{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)} + {prepnp(na,acc)}
śmiać się: _: : imperf: subj{lexnp(str,_,'oko',natr)} + {np(dat)} + {prepnp(do,gen)}
śmiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
śmiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
śmiać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
śmiać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
śmieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
śmierdzieć: _: : imperf: controller{np(dat)} + controllee{xp(mod)} + {xp(abl)}
śmierdzieć: _: : imperf: controller{prepnp(od,gen)} + controllee{xp(mod)}
śmierdzieć: _: : imperf: controller{xp(locat)} + controllee{xp(mod)}
śmierdzieć: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)}
śmierdzieć: _: : imperf: {np(inst)} + {prepnp(od,gen)}
śmierdzieć: _: : imperf: {np(inst)} + {xp(locat)}
śmierdzieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
śmierdzieć: _: : imperf: subj{np(str)} + {np(inst)}
śmieszyć: _: : imperf: subj{cp(gdy)} + {np(str)}
śmieszyć: _: : imperf: subj{cp(int)} + {np(str)}
śmieszyć: _: : imperf: subj{cp(jak)} + {np(str)}
śmieszyć: _: : imperf: subj{cp(jeśli)} + {np(str)}
śmieszyć: _: : imperf: subj{cp(kiedy)} + {np(str)}
śmieszyć: _: : imperf: subj{cp(że)} + {np(str)}
śmieszyć: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
śmigać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
śmigać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
śmigać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śmigać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
śmigać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śmignąć: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
śmignąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
śmignąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śmignąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
śmignąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śnić się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
śnić się: _: : imperf: {np(dat)} + {prepnp(o,loc)}
śnić się: _: : imperf: subj{cp(jak)} + {np(dat)}
śnić się: _: : imperf: subj{cp(żeby)} + {np(dat)}
śnić się: _: : imperf: subj{np(str); cp(że); ncp(str,że)} + {np(dat)}
śnić: _: : imperf: subj{np(str)} + {cp(jak)}
śnić: _: : imperf: subj{np(str)} + {np(str)}
śnić: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(że); prepncp(o,loc,że)}
śpieszyć się: _: : imperf: {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
śpieszyć się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
śpieszyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
śpieszyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
śpieszyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
śpieszyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
śpieszyć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
śpieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
śpieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
śpieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
śpieszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
śpieszyć: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(ku,dat); prepnp(na,acc); xp(adl)} + {xp(perl)}
śpiewać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
śpiewać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
śpiewać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
śpiewać: _: : imperf: subj{np(str)} + {np(inst)} + {or}
śpiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
świadczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
świadczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'rzecz',ratr)}
świadczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
świadczyć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
świadczyć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'niekorzyść',ratr)}
świadczyć: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)} + {advp(misc)}
świadczyć: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(przed,inst)}
świadczyć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)} + {prepnp(przed,inst)} + {cp(że)}
świadectwo: : : : {np(gen); ncp(gen,int); ncp(gen,że)} + {possp}
świadectwo: : : : {possp} + {comprepnp(co do)}
świadectwo: : : : {possp} + {comprepnp(na rzecz)}
świadectwo: : : : {possp} + {comprepnp(na temat)}
świadectwo: : : : {possp} + {comprepnp(w kwestii)}
świadectwo: : : : {possp} + {comprepnp(w sprawie)}
świadectwo: : : : {possp} + {cp(int)}
świadectwo: : : : {possp} + {cp(jakoby)}
świadectwo: : : : {possp} + {cp(że)}
świadectwo: : : : {possp} + {cp(żeby)}
świadectwo: : : : {possp} + {or}
świadectwo: : : : {possp} + {prepnp(dla,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
świadectwo: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
świadectwo: : : : {possp} + {prepnp(przeciw,dat)}
świadectwo: : : : {possp} + {prepnp(wobec,gen)}
świadectwo: : : : {possp} + {prepnp(względem,gen)}
świadectwo: : : : {possp} + {prepnp(z,gen)}
świecić się: _: : imperf: subj{lexnp(str,pl,'oko',atr)} + {np(dat)} + {prepnp(do,gen)}
świecić się: _: : imperf: subj{np(str)}
świecić: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(inst,pl,'oko',natr)}
świecić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
świecić: _: : imperf: subj{np(str)} + {np(inst)}
świecić: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc)} + {lexnp(inst,pl,'oko',natr)}
świętować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
świętować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
świnić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
świnić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
świtać: _: : imperf: {np(dat)} + {advp(misc)}
świtać: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
świtać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
świtać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
świtać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
taczać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
taczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
taczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
taczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
taić się: _: : imperf: subj{np(str)} + {cp(że)}
taić się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
taić się: _: : imperf: subj{np(str)} + {xp(locat)}
taić: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
taić: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
taić: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
taksować: _: : imperf: subj{np(str)} + {cp(że)}
taksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
taksować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
tanieć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
tańczyć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
tańczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
tańczyć: _: : imperf: subj{np(str)} + {prepnp(koło,gen)}
tańczyć: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
tapetować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
tapetować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
tapetować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
tapetować: _: : imperf: subj{np(str)} + {refl}
tapetować: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(mod)}
taplać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
taplać się: _: : imperf: subj{np(str)} + {xp(perl)}
taplać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
taranować: _: : imperf: subj{np(str)} + obj{np(str)}
targać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
targać się: _: : imperf: subj{np(str)} + {xp(adl)}
targać: _: : imperf: {np(inst)} + {prepnp(o,acc)}
targać: _: : imperf: {np(inst)} + {xp(adl)}
targać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
targać: _: : imperf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {xp(adl)}
targać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
targać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
targać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
targać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
targać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
targnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
targnąć się: _: : perf: subj{np(str)} + {xp(adl)}
targnąć: _: : perf: {np(inst)} + {prepnp(o,acc)}
targnąć: _: : perf: {np(inst)} + {xp(adl)}
targnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
targnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {xp(adl)}
targnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
targnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
targować się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
targować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
targować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
targować: _: : imperf: subj{np(str)} + {np(str)}
tarzać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,gen)}
tarzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
tarzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
tarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
tarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
tasować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
tasować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,inst)}
tchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
tchnąć: _: : imperf: {np(inst)} + {xp(abl)}
tchnąć: _: : imperf: {np(inst)} + {xp(locat)}
tchnąć: _: : imperf: subj{np(str)} + {np(inst)}
tchnąć: _: : imperf: subj{np(str)} + {xp(abl)}
telefonować: _: : imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
telefonować: _: : imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
telefonować: _: : imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
telefonować: _: : imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
telefonować: _: : imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
teoretyzować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
teoretyzować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
teoretyzować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
teoretyzować: _: : imperf: subj{np(str)} + {cp(int)}
teoretyzować: _: : imperf: subj{np(str)} + {cp(że)}
teoretyzować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
teoria: : : : {np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {possp}
teoria: : : : {possp} + {comprepnp(na temat)}
teoria: : : : {possp} + {comprepnp(w kwestii)}
teoria: : : : {possp} + {cp(jakoby)}
teoria: : : : {possp} + {cp(żeby)}
teoria: : : : {possp} + {or}
teoria: : : : {possp} + {preplexnp(w,loc,sg,'zakres',atr)}
teoria: : : : {possp} + {preplexnp(z,gen,sg,'zakres',atr)}
terminować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(locat)}
terminować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
terroryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
tępić się: _: : imperf: subj{np(str)} + {np(dat)}
tępić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
tępić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
tęsknić się: _: : imperf: {np(dat)} + {prepnp(do,gen)}
tęsknić się: _: : imperf: {np(dat)} + {prepnp(za,inst)}
tęsknić: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
tęsknić: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,jak); prepncp(za,inst,że); prepncp(za,inst,żeby)}
tętnić: _: : imperf: {np(dat)} + {np(inst)} + {xp(locat)}
tętnić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
tętnić: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
tkać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
tkać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
tkać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tkać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
tkać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
tknąć się: _: : perf: subj{np(str)} + {np(gen)}
tknąć: _: : perf: subj{cp(żeby)} + {np(str)}
tknąć: _: : perf: subj{cp(że)} + {np(str)}
tknąć: _: : perf: subj{nonch} + {np(str)} + {cp(że)}
tknąć: _: : perf: subj{nonch} + {np(str)} + {cp(żeby)}
tknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
tkwić: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
tkwić: _: : imperf: subj{np(str)} + {xp(locat)}
tlić się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
tlić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
tlić się: _: : imperf: subj{np(str)} + {np(inst)}
tlić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
tlić się: _: : imperf: {xp(locat)}
tłuc się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
tłuc się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
tłuc się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
tłuc się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
tłuc się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
tłuc się: _: : imperf: subj{np(str)} + {xp(locat)}
tłuc się: _: : imperf: subj{np(str)} + {xp(perl)}
tłuc: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
tłuc: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,_,'głowa',atr)}
tłuc: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepnp(w,acc)}
tłuc: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
tłuc: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',atr)}
tłuc: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
tłuc: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
tłuc: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
tłumaczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
tłumaczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
tłumaczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
tłumaczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
tłumaczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
tłumaczyć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
tłumaczyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
tłumaczyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
tłumaczyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
tłumaczyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
tłumaczyć: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
tłumaczyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
tłumaczyć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepadjp(na,acc)} + {prepadjp(z,gen)}
tłumaczyć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
tłumaczyć: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
tłumaczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
tłumaczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
tłumić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
to: _: : imperf: subj,controller{cp(żeby)} + controllee{advp(misc)}
to: _: : imperf: subj,controller{cp(żeby)} + controllee{np(nom)}
to: _: : imperf: subj,controller{cp(że)} + controllee{advp(misc)}
to: _: : imperf: subj,controller{cp(że)} + controllee{np(nom)}
to: _: : imperf: subj,controller{infp(_)} + controllee{infp(_)}
to: _: : imperf: subj,controller{infp(_)} + controllee{np(nom)}
to: _: : imperf: subj,controller{np(str); ncp(str,że)} + controllee{np(nom)}
toczyć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
toczyć się: _: : imperf: subj{lexnp(str,sg,'fortuna',natr)} + {lexnp(inst,sg,'koło',natr)}
toczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
toczyć się: _: : imperf: subj{np(str)} + {xp(adl)}
toczyć się: _: : imperf: subj{np(str)} + {xp(locat)}
toczyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
toczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
toczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
toczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
toczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
toczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
tolerować: _: : imperf: subj{np(str)} + {cp(gdy)}
tolerować: _: : imperf: subj{np(str)} + {cp(jak)}
tolerować: _: : imperf: subj{np(str)} + {cp(jeśli)}
tolerować: _: : imperf: subj{np(str)} + {cp(kiedy)}
tolerować: _: : imperf: subj{np(str)} + {cp(że)}
tolerować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
tolerować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
tolerować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tolerować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
tonąć: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
tonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
topić się: _: : imperf: subj{np(str)} + {np(dat)}
topić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
topić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
topnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
topnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
topnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
topnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
torować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
torować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
towarzyszyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
towarzyszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
towarzyszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
towarzyszyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
towarzyszyć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
towarzyszyć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
tracić: _: : imperf: subj{np(str)} + {lexnp(str,sg,'grunt',natr)} + {preplexnp(pod,inst,pl,'noga',natr)}
tracić: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,pl,'oko',natr)}
tracić: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
tracić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
tracić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
tracić: _: : imperf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',ratr)}
tracić: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,sg,'serce',natr)}
tracić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,sg,'serce',natr)}
tracić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {nonch}
trafiać się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
trafiać się: _: : imperf: subj{cp(że)} + {np(dat)}
trafiać się: _: : imperf: subj{np(str)} + {np(dat)}
trafiać: _: : imperf: {prepnp(na,acc)}
trafiać: _: : imperf: subj{cp(int)} + {prepnp(do,gen)}
trafiać: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
trafiać: _: : imperf: subj{cp(że)} + {prepnp(do,gen)}
trafiać: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(do,gen)}
trafiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
trafiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
trafiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trafiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trafiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
trafiać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
trafiać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
trafiać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
trafiać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
trafiać: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
trafiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
trafiać: _: : imperf: subj{np(str)} + {xp(adl)}
trafić się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
trafić się: _: : perf: subj{cp(że)} + {np(dat)}
trafić się: _: : perf: subj{np(str)} + {np(dat)}
trafić: _: : perf: {prepnp(na,acc)}
trafić: _: : perf: subj{cp(int)} + {prepnp(do,gen)}
trafić: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
trafić: _: : perf: subj{cp(że)} + {prepnp(do,gen)}
trafić: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(do,gen)}
trafić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
trafić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
trafić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trafić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
trafić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
trafić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
trafić: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
trafić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
trafić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
trafić: _: : perf: subj{np(str)} + {prepnp(za,inst)}
trafić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
trafić: _: : perf: subj{np(str)} + {xp(adl)}
tragedia: : : : {possp} + {comprepnp(na temat)}
tragedia: : : : {possp} + {comprepnp(z powodu)}
tragedia: : : : {possp} + {cp(że)}
tragedia: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
tragedia: : : : {possp} + {prepnp(z,inst)}
traktować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
traktować: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{xp(mod)}
traktować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
traktować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
traktować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
transportować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
transportować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
transportować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
trapić się: _: : imperf: subj{np(str)} + {cp(int)}
trapić się: _: : imperf: subj{np(str)} + {cp(że)}
trapić się: _: : imperf: subj{np(str)} + {cp(żeby)}
trapić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
trapić się: _: : imperf: subj{np(str)} + {or}
trapić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
trapić: _: : imperf: subj{cp(int)} + {np(str)}
trapić: _: : imperf: subj{cp(że)} + {np(str)}
trapić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
trapić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tratować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
tratować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
trącać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
trącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trącić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
trącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
trącić: _: : imperf: subj{np(str)} + {np(inst)}
trenować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
trenować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
trenować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
trenować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
trenować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
triumfować: _: : imperf: subj{np(str)} + {cp(że)}
triumfować: _: : imperf: subj{np(str)} + {np(inst)}
triumfować: _: : imperf: subj{np(str)} + {or}
triumfować: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
tropić się: _: : imperf: subj{np(str)}
tropić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tropić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
tropić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
tropić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
tropić: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(locat)}
tropić: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(perl)}
troska: : : : {np(inst)} + {possp}
troska: : : : {possp} + {comprepnp(w stosunku do)}
troska: : : : {possp} + {comprepnp(z powodu)}
troska: : : : {possp} + {cp(int)}
troska: : : : {possp} + {cp(że)}
troska: : : : {possp} + {cp(żeby)}
troska: : : : {possp} + {or}
troska: : : : {possp} + {prepnp(dla,gen)}
troska: : : : {possp} + {prepnp(nad,inst)}
troska: : : : {possp} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
troska: : : : {possp} + {prepnp(wobec,gen)}
troska: : : : {possp} + {prepnp(względem,gen)}
troszczyć się: _: : imperf: subj{np(str)} + {cp(int)}
troszczyć się: _: : imperf: subj{np(str)} + {cp(że)}
troszczyć się: _: : imperf: subj{np(str)} + {cp(żeby)}
troszczyć się: _: : imperf: subj{np(str)} + {np(inst)}
troszczyć się: _: : imperf: subj{np(str)} + {or}
troszczyć się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
truchtać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
truchtać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
truchtać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
truć się: _: : imperf: subj{np(str)} + {np(inst)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {lexnp(str,sg,'dupa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {lexnp(str,sg,'głowa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {lexnp(str,sg,'dupa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {lexnp(str,sg,'głowa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {lexnp(str,sg,'dupa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {lexnp(str,sg,'głowa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'dupa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'głowa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {lexnp(str,sg,'dupa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {lexnp(str,sg,'głowa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {lexnp(str,sg,'dupa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {lexnp(str,sg,'głowa',natr)}
truć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
truć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
truć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
trudnić się: _: : imperf: subj{np(str)} + {np(inst)}
trudno: _: : _: controller{np(dat)} + controllee{infp(_)}
trudzić się: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
trudzić się: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
trudzić się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
trudzić się: _: : imperf: subj{np(str)} + {cp(żeby)}
trudzić się: _: : imperf: subj{np(str)} + {np(inst)}
trudzić się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
trudzić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
trudzić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
trudzić się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
trudzić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
trudzić się: _: : imperf: subj{np(str)} + {xp(adl)}
trudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
trudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trwać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(dur)}
trwać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
trwać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
trwać: _: : imperf: subj{np(str)} + {xp(locat)}
trwonić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
tryskać: _: : imperf: {np(inst)} + {prepnp(od,gen)}
tryskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
tryskać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
tryskać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
trza: _: : imperf: {advp(pron)}
trza: _: : imperf: controller{np(dat)} + controllee{infp(_)}
trza: _: : imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
trza: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
trza: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
trza: _: : imperf: {np(gen)} + {cp(że)}
trzaskać: _: : imperf: {np(dat)} + {xp(locat)}
trzaskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
trzaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
trzaskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzaskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trzaskać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
trzasnąć: _: : perf: {np(dat)} + {xp(locat)}
trzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
trzasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
trzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trzasnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
trząść się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jak,str)}
trząść się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepnp(z,gen)}
trząść się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
trząść się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
trząść się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
trząść się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'posada',natr)}
trząść: _: : imperf: {np(inst)}
trząść: _: : imperf: {np(str)}
trząść: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
trząść: _: : imperf: subj{np(str)} + obj{np(str)}
trzeba: _: : imperf: {advp(pron)}
trzeba: _: : imperf: controller{np(dat)} + controllee{infp(_)}
trzeba: _: : imperf: {np(dat)} + {cp(żeby)}
trzeba: _: : imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
trzeba: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
trzeba: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
trzeba: _: : imperf: {np(gen)} + {cp(że)}
trzeć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzeć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzeć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzeć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
trzeć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzeć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
trzeć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
trzeć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
trzepać się: _: : imperf: subj{np(str)} + {xp(locat)}
trzepać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
trzepać: _: : imperf: subj{np(str)} + {np(inst)} + {or}
trzepać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzepać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzepać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
trzepać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzepać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trzepać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
trzepnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzepnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzepnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
trzepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trzeźwić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
trzeźwić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
trzeźwić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trzeźwić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
trzeźwić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
trzeźwić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
trzeźwić: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
trzeźwieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
tulić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
tulić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
tulić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
tulić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
tupać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
tupać: _: : imperf: subj{np(str)} + {np(inst)} + {or}
tupać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
tupać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
tupać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
tupać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
tupać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
tupać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
tupać: _: : imperf: subj{np(str)} + {xp(perl)}
tupnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
tupnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
tupnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
tupnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
tupnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
twierdzić: _: : imperf: subj{np(str)} + {advp(pron)}
twierdzić: _: : imperf: subj{np(str)} + {cp(jakoby)}
twierdzić: _: : imperf: subj{np(str)} + {cp(że)}
twierdzić: _: : imperf: subj{np(str)} + {cp(żeby)}
twierdzić: _: : imperf: subj{np(str)} + {nonch}
twierdzić: _: : imperf: subj{np(str)} + {or}
tworzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
tworzyć się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
tworzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tworzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
tyć: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
tyć: _: : imperf: subj{np(str)} + {np(str)}
tyć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
tyć: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
tyć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
tyć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
tykać się: _: : imperf: subj{np(str)} + {np(gen)}
tykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tyknąć: _: : perf: subj{np(str)}
typować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
typować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
typować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
tyrać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
tyrać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
tyrać: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
tyrać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
tyrać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
tyrać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
tyrać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
tyrać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
tyrać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
uaktualniać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uaktualniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uaktualniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uaktualnić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uaktualnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uaktualnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uaktywniać się: _: : imperf: subj{np(str)} + {np(dat)}
uaktywniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uaktywnić się: _: : perf: subj{np(str)} + {np(dat)}
uaktywnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uatrakcyjniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
uatrakcyjnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
ubezpieczać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {xp(locat)}
ubezpieczać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
ubezpieczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {xp(locat)}
ubezpieczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ubezpieczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {xp(locat)}
ubezpieczyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
ubezpieczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {xp(locat)}
ubezpieczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ubezwłasnowolnić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ubezwłasnowolnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubiec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ubiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
ubiegać się: _: : imperf: subj{np(str)} + {cp(żeby)}
ubiegać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
ubiegać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ubiegać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
ubierać się: _: : imperf: subj{np(str)} + {xp(locat)}
ubierać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)} + {refl}
ubierać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)}
ubierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ubierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubliżać: _: : imperf: subj{cp(że)} + {np(dat)}
ubliżać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
ubliżać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
ubliżać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ubliżać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ubliżyć: _: : perf: subj{cp(że)} + {np(dat)}
ubliżyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
ubliżyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
ubliżyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ubliżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ubogi: : : : {np(inst)}
ubogi: : : : {preplexnp(z,gen,sg,'dom',natr)}
ubogi: : : : {prepnp(o,acc); prepncp(o,acc,że)}
ubogi: : : : {prepnp(w,acc)}
ubogi: : : : {prepnp(w,loc)}
ubolewać: _: : imperf: subj{np(str)} + {cp(że)}
ubolewać: _: : imperf: subj{np(str)} + {or}
ubolewać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
ubożyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ubóść: _: : perf: subj{cp(gdy)} + {np(str)}
ubóść: _: : perf: subj{cp(int)} + {np(str)}
ubóść: _: : perf: subj{cp(jak)} + {np(str)}
ubóść: _: : perf: subj{cp(jeśli)} + {np(str)}
ubóść: _: : perf: subj{cp(kiedy)} + {np(str)}
ubóść: _: : perf: subj{cp(że)} + {np(str)}
ubóść: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
ubóść: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
ubóść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ubrać się: _: : perf: subj{np(str)} + {xp(locat)}
ubrać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)} + {refl}
ubrać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)}
ubrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ubrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubyć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(od,gen)}
ubyć: _: : perf: {np(dat)} + {np(gen)} + {xp(abl)}
ubyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ubyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
ubywać: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(od,gen)}
ubywać: _: : imperf: {np(dat)} + {np(gen)} + {xp(abl)}
ubywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ubywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
ucałować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
ucałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ucałować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'dubeltówka',natr)}
ucałować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
uchodzić: _: : imperf: controller{np(dat)} + controllee{infp(_)}
uchodzić: _: : imperf: subj,controller{cp(że)} + controllee{prepnp(za,acc)}
uchodzić: _: : imperf: subj,controller{infp(_)} + controllee{prepnp(za,acc)}
uchodzić: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)}
uchodzić: _: : imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)}
uchodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
uchodzić: _: : imperf: subj{np(str)} + {xp(abl)}
uchować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
uchować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
uchować się: _: : perf: subj{np(str)} + {xp(locat)}
uchować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uchować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uchować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uchować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uchronić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uchronić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
uchronić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {refl}
uchronić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {refl}
uchronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uchronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
uchwalać: _: : imperf: subj{np(str)} + obj{cp(int)}
uchwalać: _: : imperf: subj{np(str)} + obj{cp(że)}
uchwalać: _: : imperf: subj{np(str)} + obj{cp(żeby)}
uchwalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
uchwalić: _: : perf: subj{np(str)} + obj{cp(int)}
uchwalić: _: : perf: subj{np(str)} + obj{cp(że)}
uchwalić: _: : perf: subj{np(str)} + obj{cp(żeby)}
uchwalić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
uchwycić się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
uchwycić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
uchwycić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
uchwycić: _: : perf: subj{np(str)} + obj{cp(jak)} + {np(inst)}
uchwycić: _: : perf: subj{np(str)} + obj{cp(kiedy)} + {np(inst)}
uchwycić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(inst)}
uchwycić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(inst)}
uchwycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
uchwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
uchwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uchwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uchwycić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
uchwycić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
uchybiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uchybiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uchybić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uchybić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uchylać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
uchylać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
uchylać się: _: : imperf: subj{np(str)} + {xp(adl)}
uchylać: _: : imperf: subj{np(str)} + {np(dat)} + {fixed('rąbek tajemnicy')}
uchylać: _: : imperf: subj{np(str)} + {np(dat)} + {fixed('rąbka tajemnicy')}
uchylać: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(przed,inst)}
uchylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uchylać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {fixed('rąbek tajemnicy')}
uchylać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {fixed('rąbka tajemnicy')}
uchylić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
uchylić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
uchylić się: _: : perf: subj{np(str)} + {xp(adl)}
uchylić: _: : perf: subj{np(str)} + {np(dat)} + {fixed('rąbek tajemnicy')}
uchylić: _: : perf: subj{np(str)} + {np(dat)} + {fixed('rąbka tajemnicy')}
uchylić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(przed,inst)}
uchylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uchylić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {fixed('rąbek tajemnicy')}
uchylić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {fixed('rąbka tajemnicy')}
uciąć się: _: : perf: subj{np(str)} + {np(dat)}
uciąć się: _: : perf: subj{np(str)} + {xp(locat)}
uciąć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'drzemka',atr)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
uciąć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'partyjka',atr)} + {lexnp(dat,_,'siebie',natr)}
uciąć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'pogawędka',atr)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
uciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
uciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uciąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ucichnąć: _: : perf: subj{np(str)}
ucichnąć: _: : perf: {xp(locat)}
uciemiężyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ucierać się: _: : imperf: subj{cp(że)}
ucierać się: _: : imperf: subj{cp(żeby)}
ucierać się: _: : imperf: subj{infp(imperf)}
ucierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ucierać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {lexnp(gen,sg,'nos',natr)}
ucierać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
ucierać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
ucierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,inst)}
ucierpieć: _: : perf: subj{np(str)} + {prepnp(od,gen); prepnp(przez,acc); comprepnp(z powodu); prepncp(od,gen,że); prepncp(przez,acc,że); xp(temp); preplexnp(na,acc,sg,'skutek',natr); preplexnp(w,loc,sg,'wynik',natr)} + {advp(misc)}
ucieszyć się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
ucieszyć się: _: : perf: subj{np(str)} + {cp(że)}
ucieszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ucieszyć się: _: : perf: subj{np(str)} + {or}
ucieszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
ucieszyć się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
ucieszyć: _: : perf: subj{cp(gdy)} + {np(str)}
ucieszyć: _: : perf: subj{cp(int)} + {np(str)}
ucieszyć: _: : perf: subj{cp(jak)} + {np(str)}
ucieszyć: _: : perf: subj{cp(jeśli)} + {np(str)}
ucieszyć: _: : perf: subj{cp(kiedy)} + {np(str)}
ucieszyć: _: : perf: subj{cp(że)} + {np(str)}
ucieszyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
ucieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ucinać się: _: : imperf: subj{np(str)} + {np(dat)}
ucinać się: _: : imperf: subj{np(str)} + {xp(locat)}
ucinać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'drzemka',atr)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
ucinać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'partyjka',atr)} + {lexnp(dat,_,'siebie',natr)}
ucinać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'pogawędka',atr)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
ucinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ucinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ucinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
ucinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ucinać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uciszać się: _: : imperf: subj{E}
uciszać się: _: : imperf: subj{np(str)}
uciszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uciszyć się: _: : perf: subj{E}
uciszyć się: _: : perf: subj{np(str)}
uciszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uciułać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uciułać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ucywilizować się: _: : perf: subj{np(str)}
ucywilizować: _: : perf: subj{np(str)} + obj{np(str)}
uczcić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
uczesać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
uczesać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
uczesać się: _: : perf: subj{np(str)} + {xp(locat)}
uczesać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
uczesać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
uczesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
uczestniczyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
uczęszczać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
uczęszczać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
ucztować: _: : imperf: subj{np(str)}
uczucie: : : : {np(gen)} + {possp} + {prepnp(co do,gen); prepnp(do,gen)}
uczucie: : : : {np(gen)} + {possp} + {prepnp(dla,gen)}
uczucie: : : : {np(gen)} + {prepnp(między,inst)}
uczucie: : : : {np(gen)} + {xp(locat)}
uczucie: : : : {possp} + {comprepnp(na temat)}
uczucie: : : : {possp} + {comprepnp(w sprawie)}
uczucie: : : : {possp} + {comprepnp(w stosunku do)}
uczucie: : : : {possp} + {comprepnp(z powodu)}
uczucie: : : : {possp} + {cp(jakby)}
uczucie: : : : {possp} + {cp(że)}
uczucie: : : : {possp} + {prepnp(wobec,gen)}
uczucie: : : : {possp} + {prepnp(względem,gen)}
uczuć się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
uczuć się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
uczuć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
uczuć: _: : perf: subj{np(str)} + {cp(int)}
uczuć: _: : perf: subj{np(str)} + {cp(jakby)}
uczuć: _: : perf: subj{np(str)} + {cp(jak); cp(że)}
uczuć: _: : perf: subj{np(str)} + {cp(jakoby)}
uczuć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
uczuć: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
uczulać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
uczulać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
uczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
uczulić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
uczulić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
uczulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
uczyć się: _: : imperf: subj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {prepnp(od,gen); prepnp(z,gen); prepnp(z,inst)}
uczyć się: _: : imperf: subj{np(str)} + {advp(misc)}
uczyć się: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
uczyć się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
uczyć się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
uczyć się: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
uczyć się: _: : imperf: subj{np(str)} + {preplexnp(na,loc,pl,'błąd',batr)}
uczyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
uczyć się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
uczyć: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
uczyć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {np(inst)}
uczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
uczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
uczynić się: _: : perf: {np(dat)} + {xp(locat)} + {advp(misc)}
uczynić się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
uczynić: _: : perf: subj{np(str)} + {cp(że)} + {advp(misc)}
uczynić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
uczynić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uczynić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uczynić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uczynić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uczynić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
uczynić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uczynić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
udać się: _: : perf: controller{np(dat)} + controllee{infp(_)}
udać się: _: : perf: subj{np(str)} + {np(dat)}
udać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
udać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
udać się: _: : perf: subj{np(str)} + {xp(adl)}
udać: _: : perf: subj,controller{np(str)} + controllee{adjp(str)}
udać: _: : perf: subj,controller{np(str)} + controllee{np(str)}
udać: _: : perf: subj{np(str)} + {cp(że)}
udać: _: : perf: subj{np(str)} + obj{np(str)}
udaremnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
udawać się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
udawać się: _: : imperf: subj{np(str)} + {np(dat)}
udawać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
udawać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
udawać się: _: : imperf: subj{np(str)} + {xp(adl)}
udawać: _: : imperf: subj,controller{np(str)} + controllee{adjp(str)}
udawać: _: : imperf: subj,controller{np(str)} + controllee{np(str)}
udawać: _: : imperf: subj{np(str)} + {cp(że)}
udawać: _: : imperf: subj{np(str)} + obj{np(str)}
udekorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uderzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
uderzać: _: : imperf: subj{cp(że)} + {np(str)}
uderzać: _: : imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {advp(misc)}
uderzać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
uderzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uderzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
uderzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
uderzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
uderzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uderzać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
uderzać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uderzać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
uderzać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
uderzać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
uderzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
uderzyć: _: : perf: subj{cp(że)} + {np(str)}
uderzyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
uderzyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uderzyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
uderzyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
uderzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
uderzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
uderzyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uderzyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
uderzyć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
uderzyć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
udokumentować: _: : perf: subj{np(str)} + obj{cp(int); cp(że)} + {np(inst)}
udokumentować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
udoskonalać się: _: : imperf: subj{np(str)}
udoskonalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
udoskonalić się: _: : perf: subj{np(str)}
udoskonalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
udostępniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepnp(pod,acc)} + {xp(locat)}
udostępniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
udostępnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepnp(pod,acc)} + {xp(locat)}
udostępnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
udowadniać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
udowadniać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
udowadniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
udowadniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
udowodnić: _: : perf: subj{np(str)} + {np(dat)} + {or}
udowodnić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
udowodnić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
udowodnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
udrapować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
udrapować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
udrapować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
udrapować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
udrapować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
udrapować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
udrapować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
udrażniać się: _: : imperf: subj{np(str)} + {np(dat)}
udrażniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
udręczyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
udręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
udrożnić się: _: : perf: subj{np(str)} + {np(dat)}
udrożnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uduchowić się: _: : perf: subj{np(str)}
uduchowić: _: : perf: subj{np(str)} + obj{np(str)}
udusić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
udusić się: _: : perf: subj{np(str)} + {np(inst)}
udusić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
udusić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
udusić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
udusić się: _: : perf: subj{np(str)} + {xp(locat)}
udusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
udusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
udział: : : : {np(gen)} + {comprepnp(w stosunku do)}
udział: : : : {np(gen)} + {prepnp(w,loc)}
udział: : : : {np(gen)} + {prepnp(wobec,gen)}
udział: : : : {np(gen)} + {prepnp(względem,gen)}
udział: : : : {possp} + {comprepnp(w sprawie)}
udział: : : : {possp} + {prepnp(w,loc)} + {comprepnp(po stronie)}
udział: : : : {possp} + {prepnp(w,loc)} + {comprepnp(w roli)}
udział: : : : {possp} + {prepnp(z,gen)}
udzielać się: _: : imperf: subj{np(str)} + {advp(misc)}
udzielać się: _: : imperf: subj{np(str)} + {np(dat)}
udzielać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
udzielać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
udzielać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)}
udzielić się: _: : perf: subj{np(str)} + {advp(misc)}
udzielić się: _: : perf: subj{np(str)} + {np(dat)}
udzielić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
udzielić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
udzielić: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)}
udźwignąć: _: : perf: subj{np(str)} + obj{np(str)}
ufać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
ufać: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że)}
ufać: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
uformować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
uformować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
uformować się: _: : perf: subj{np(str)} + {xp(locat)}
uformować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uformować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uformować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ufundować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ufundować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ugasić się: _: : perf: subj{np(str)}
ugasić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ugasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ugasić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'zarodek',natr)}
ugiąć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
ugiąć się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
ugiąć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
ugiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ugiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ugiąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(gen,sg,'kark',batr)}
uginać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
uginać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
uginać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
uginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uginać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(gen,sg,'kark',batr)}
ugodzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
ugodzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
ugodzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
ugodzić: _: : perf: subj{cp(gdy)} + {np(str)}
ugodzić: _: : perf: subj{cp(int)} + {np(str)}
ugodzić: _: : perf: subj{cp(jak)} + {np(str)}
ugodzić: _: : perf: subj{cp(jeśli)} + {np(str)}
ugodzić: _: : perf: subj{cp(kiedy)} + {np(str)}
ugodzić: _: : perf: subj{cp(że)} + {np(str)}
ugodzić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
ugodzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ugodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ugodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ugotować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
ugotować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
ugotować się: _: : perf: subj{np(str)} + {xp(locat)}
ugotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ugotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
ugruntować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
ugruntować się: _: : perf: subj{np(str)} + {xp(locat)}
ugruntować: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
ugruntować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
ugruntowywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
ugruntowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
ugruntowywać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
ugruntowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
ugryźć: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
ugryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ugryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ugryźć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ugrzęznąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
ugrzęznąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
ugrzęznąć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
uhonorować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
uhonorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
uiszczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uiszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uiścić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uiścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ujawniać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
ujawniać się: _: : imperf: subj{cp(int)} + {np(dat)} + {xp(locat)}
ujawniać się: _: : imperf: subj{cp(int)} + {np(dat)} + {xp(temp)}
ujawniać się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
ujawniać się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(temp)}
ujawniać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(locat)}
ujawniać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(temp)}
ujawniać: _: : imperf: subj{np(str)} + obj{cp(int); cp(że)} + {np(dat)}
ujawniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
ujawnić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
ujawnić się: _: : perf: subj{cp(int)} + {np(dat)} + {xp(locat)}
ujawnić się: _: : perf: subj{cp(int)} + {np(dat)} + {xp(temp)}
ujawnić się: _: : perf: subj{cp(że)} + {np(dat)} + {xp(locat)}
ujawnić się: _: : perf: subj{cp(że)} + {np(dat)} + {xp(temp)}
ujawnić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(locat)}
ujawnić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(temp)}
ujawnić: _: : perf: subj{np(str)} + obj{cp(int); cp(że)} + {np(dat)}
ujawnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
ująć się: _: : perf: subj{np(str)} + {lexnp(inst,sg,'honor',natr)}
ująć się: _: : perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)} + {or}
ująć: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {or}
ująć: _: : perf: subj{cp(że)} + {np(str)} + {prepnp(w,loc)}
ująć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
ująć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
ująć: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
ująć: _: : perf: subj{np(str)} + obj{cp(że)}
ująć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ująć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ująć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
ująć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
ująć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ująć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ująć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
ująć: _: : perf: subj{np(str)} + {prepnp(pod,acc)} + {refl}
ująć: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
ujednolicać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
ujednolicać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
ujednolicić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
ujednolicić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
ujeździć się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
ujeździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ujeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
ujeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ujeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
ujmować się: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'honor',natr)}
ujmować się: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)} + {or}
ujmować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {or}
ujmować: _: : imperf: subj{cp(że)} + {np(str)} + {prepnp(w,loc)}
ujmować: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
ujmować: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
ujmować: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
ujmować: _: : imperf: subj{np(str)} + obj{cp(że)}
ujmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ujmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ujmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
ujmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
ujmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ujmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ujmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
ujmować: _: : imperf: subj{np(str)} + {prepnp(pod,acc)} + {refl}
ujmować: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
ujrzeć: _: : perf: subj{np(str)} + {cp(int)}
ujrzeć: _: : perf: subj{np(str)} + {cp(jak)}
ujrzeć: _: : perf: subj{np(str)} + {cp(że)}
ujrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'oko',batr)}
ujrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ukarać: _: : perf: subj{np(str)} + {np(inst)} + {prepncp(za,acc,że)} + {refl}
ukarać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
ukarać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepncp(za,acc,że)}
ukarać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ukazać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
ukazać się: _: : perf: subj{np(str)} + {np(dat)}
ukazać się: _: : perf: subj{np(str)} + {xp(locat)}
ukazać: _: : perf: subj{np(str)} + {cp(int)}
ukazać: _: : perf: subj{np(str)} + {cp(że)}
ukazać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ukazać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
ukazywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
ukazywać się: _: : imperf: subj{np(str)} + {np(dat)}
ukazywać się: _: : imperf: subj{np(str)} + {xp(locat)}
ukazywać: _: : imperf: subj{np(str)} + {cp(int)}
ukazywać: _: : imperf: subj{np(str)} + {cp(że)}
ukazywać: _: : imperf: subj{np(str)} + {ncp(str,int)}
ukazywać: _: : imperf: subj{np(str)} + {ncp(str,że)}
ukazywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ukazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ukąsić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
układać się: _: : imperf: {np(dat)} + {prepnp(w,loc)} + {advp(misc)}
układać się: _: : imperf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
układać się: _: : imperf: subj,controller{np(str)} + controllee{fixed('spać')}
układać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
układać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
układać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {advp(misc)}
układać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
układać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
układać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
układać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
układać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
układać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
układać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
układać się: _: : imperf: subj{np(str)} + {xp(locat)}
układać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{fixed('spać')}
układać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
układać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
układać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
układać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
układać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
układać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
układać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
układać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ukochać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ukonstytuować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
ukonstytuować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
ukonstytuować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ukonstytuować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ukończyć: _: : perf: subj{np(str)} + obj{np(str)}
ukoronować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ukoronować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ukoronować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ukoronować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
ukraść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
ukręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
ukręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ukręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ukręcić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
ukręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ukręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ukryć się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
ukryć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
ukryć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
ukryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
ukryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
ukrywać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
ukrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
ukrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
ukrywać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
ukrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
ukrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
ukrzyżować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
ukształtować się: _: : perf: subj{np(str)} + {np(inst)}
ukształtować się: _: : perf: subj{np(str)} + {xp(locat)}
ukształtować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ukształtować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ulatniać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ulec: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ulec: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ulec: _: : perf: subj{np(str)} + {np(dat); ncp(dat,że)}
ulec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulegać: _: : imperf: subj{cp(int)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: _: : imperf: subj{cp(int)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: _: : imperf: subj{cp(że)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: _: : imperf: subj{cp(że)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ulegać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ulegać: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że)}
ulegać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulepić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ulepić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
ulepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
ulepszać: _: : imperf: subj{np(str)} + obj{np(str)}
ulepszyć: _: : perf: subj{np(str)} + obj{np(str)}
ulokować się: _: : perf: subj{np(str)} + {xp(locat)}
ulokować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ulokować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ulokować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ulotnić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ulżyć: _: : perf: {np(dat)} + {prepnp(w,loc)}
ulżyć: _: : perf: subj{cp(gdy)} + {np(dat)}
ulżyć: _: : perf: subj{cp(jak)} + {np(dat)}
ulżyć: _: : perf: subj{cp(jeśli)} + {np(dat)}
ulżyć: _: : perf: subj{cp(kiedy)} + {np(dat)}
ulżyć: _: : perf: subj{cp(że)} + {np(dat)}
ulżyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(dat)}
ulżyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
ułatwiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
ułatwić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
ułożyć się: _: : perf: {np(dat)} + {prepnp(w,loc)} + {advp(misc)}
ułożyć się: _: : perf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
ułożyć się: _: : perf: subj,controller{np(str)} + controllee{fixed('spać')}
ułożyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
ułożyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ułożyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {advp(misc)}
ułożyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
ułożyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
ułożyć się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
ułożyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
ułożyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
ułożyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
ułożyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
ułożyć się: _: : perf: subj{np(str)} + {xp(locat)}
ułożyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{fixed('spać')}
ułożyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ułożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ułożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ułożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ułożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
ułożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ułożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ułożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umacniać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
umacniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
umacniać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
umacniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
umalować: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
umalować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
umalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
umalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
umalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
umarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)} + {prepnp(z,inst)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(z,inst)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,int)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,że)}
umawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)} + {xp(temp)}
umawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
umawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
umeblować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umieć: _: : imperf: subj,controller{np(str)} + controllee{np(str); infp(_)}
umieć: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
umiejscawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
umiejscawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umiejscowić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
umiejscowić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umierać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
umierać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
umierać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
umierać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
umieszczać się: _: : imperf: subj{np(str)} + {xp(locat)}
umieszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umieszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umieścić się: _: : perf: subj{np(str)} + {xp(locat)}
umieścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umieścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umilać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umilić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umilknąć: _: : perf: subj{np(str)}
umiłować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
umknąć: _: : perf: subj{cp(int)} + {lexnp(gen,sg,'uwaga',ratr)}
umknąć: _: : perf: subj{cp(int)} + {np(dat)}
umknąć: _: : perf: subj{cp(że)} + {lexnp(gen,sg,'uwaga',ratr)}
umknąć: _: : perf: subj{cp(że)} + {np(dat)}
umknąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(gen,sg,'uwaga',ratr)}
umknąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
umknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
umknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {xp(adl)} + {xp(perl)}
umknąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
umniejszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
umniejszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
umniejszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
umniejszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
umniejszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
umniejszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
umniejszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
umniejszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
umocnić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
umocnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
umocnić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
umocnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
umocować się: _: : perf: subj{np(str)} + {xp(locat)}
umocować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
umocować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
umocować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
umorzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
umotywować: _: : perf: subj{np(str)} + {cp(że)}
umotywować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
umotywować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
umotywować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
umotywować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
umotywować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
umotywować: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)} + {refl}
umożliwiać: _: : imperf: subj{ncp(str,że)} + obj{np(str)}
umożliwiać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
umożliwiać: _: : imperf: subj{np(str)} + {cp(że)}
umożliwiać: _: : imperf: subj{np(str)} + {cp(żeby)}
umożliwiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
umożliwić: _: : perf: subj{ncp(str,że)} + obj{np(str)}
umożliwić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
umożliwić: _: : perf: subj{np(str)} + {cp(że)}
umożliwić: _: : perf: subj{np(str)} + {cp(żeby)}
umożliwić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
umówić się: _: : perf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)} + {prepnp(z,inst)}
umówić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(z,inst)}
umówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
umówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
umówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,int)}
umówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,że)}
umówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)} + {xp(temp)}
umówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
umówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
umrzeć: _: : perf: {preplexnp(w,loc,pl,'but',natr)}
umrzeć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
umrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
umrzeć: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
umrzeć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
umundurować: _: : perf: subj{np(str)} + obj{np(str)}
umundurować: _: : perf: subj{np(str)} + {refl}
umyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
umyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umyć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {lexnp(str,pl,'ręka',natr)}
umykać: _: : imperf: subj{cp(int)} + {lexnp(gen,sg,'uwaga',ratr)}
umykać: _: : imperf: subj{cp(int)} + {np(dat)}
umykać: _: : imperf: subj{cp(że)} + {lexnp(gen,sg,'uwaga',ratr)}
umykać: _: : imperf: subj{cp(że)} + {np(dat)}
umykać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(gen,sg,'uwaga',ratr)}
umykać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
umykać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
umykać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {xp(adl)} + {xp(perl)}
umykać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
umywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
umywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,sg,'wzgląd',natr)}
umywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {lexnp(str,pl,'ręka',natr)}
uniemożliwiać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
uniemożliwiać: _: : imperf: subj{np(str)} + {cp(żeby)}
uniemożliwiać: _: : imperf: subj{np(str)} + {ncp(str,żeby)}
uniemożliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uniemożliwić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
uniemożliwić: _: : perf: subj{np(str)} + {cp(żeby)}
uniemożliwić: _: : perf: subj{np(str)} + {ncp(str,żeby)}
uniemożliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
unieszkodliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
unieszkodliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
unieważniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
unieważnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uniewinniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uniewinniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uniewinniać: _: : imperf: subj{np(str)} + {or} + {refl}
uniewinnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uniewinnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uniewinnić: _: : perf: subj{np(str)} + {refl}
uniezależniać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {advp(misc)}
uniezależniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {advp(misc)}
uniezależnić się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {advp(misc)}
uniezależnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {advp(misc)}
unikać: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,że); ncp(gen,żeby)}
uniknąć: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,że); ncp(gen,żeby)}
unormować się: _: : perf: subj{np(str)} + {np(dat)}
unormować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
unowocześniać się: _: : imperf: subj{np(str)}
unowocześniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
unowocześnić się: _: : perf: subj{np(str)}
unowocześnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uodparniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
uodparniać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
uodparniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uodparniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
uodpornić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
uodpornić się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
uodpornić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uodpornić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
uogólniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
uogólniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uogólnić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
uogólnić: _: : perf: subj{np(str)} + {cp(że)}
uogólnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
upadać: _: : imperf: subj{np(str)} + {advp(misc)}
upadać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
upadać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
upadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
upadać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
upadać: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
upadać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
upajać się: _: : imperf: subj{np(str)} + {cp(int)}
upajać się: _: : imperf: subj{np(str)} + {cp(że)}
upajać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
upajać się: _: : imperf: subj{np(str)} + {or}
upajać: _: : imperf: subj{cp(int)} + {np(str)}
upajać: _: : imperf: subj{cp(że)} + {np(str)}
upajać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
upajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
upamiętniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
upamiętniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
upamiętniać: _: : imperf: subj{np(str)} + {cp(że)}
upamiętniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
upamiętnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
upamiętnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
upamiętnić: _: : perf: subj{np(str)} + {cp(że)}
upamiętnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
upaństwawiać: _: : imperf: subj{np(str)} + obj{np(str)}
upaństwowić: _: : perf: subj{np(str)} + obj{np(str)}
upaść się: _: : perf: subj{np(str)} + {np(inst)}
upaść się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
upaść: _: : perf: subj{np(str)} + {advp(misc)}
upaść: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
upaść: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
upaść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
upaść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
upaść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
upaść: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
upaść: _: : perf: subj{np(str)} + {prepnp(z,gen)}
upatrywać: _: : imperf: subj{np(str)} + {cp(int)}
upatrywać: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
upatrywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
upatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {lexnp(dat,_,'siebie',natr)}
upatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {lexnp(dat,_,'siebie',natr)}
upatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
upatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
upatrywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
upatrzyć: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
upatrzyć: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
upatrzyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
upatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {lexnp(dat,_,'siebie',natr)}
upatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {lexnp(dat,_,'siebie',natr)}
upatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
upatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
upchać się: _: : perf: subj{np(str)} + {xp(adl)}
upchać się: _: : perf: subj{np(str)} + {xp(locat)}
upchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
upchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
upchnąć się: _: : perf: subj{np(str)} + {xp(adl)}
upchnąć się: _: : perf: subj{np(str)} + {xp(locat)}
upchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
upchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
upewniać się: _: : imperf: subj{np(str)} + {cp(int)}
upewniać się: _: : imperf: subj{np(str)} + {cp(że)}
upewniać się: _: : imperf: subj{np(str)} + {or}
upewniać się: _: : imperf: subj{np(str)} + {prepncp(o,loc,że)}
upewniać się: _: : imperf: subj{np(str)} + {prepncp(w,loc,że)}
upewniać się: _: : imperf: subj{np(str)} + {prepnp(co do,gen)}
upewniać się: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
upewniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
upewniać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
upewniać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
upewniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(co do,gen,że)}
upewniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,że)}
upewniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
upewniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)}
upewnić się: _: : perf: subj{np(str)} + {cp(int)}
upewnić się: _: : perf: subj{np(str)} + {cp(że)}
upewnić się: _: : perf: subj{np(str)} + {or}
upewnić się: _: : perf: subj{np(str)} + {prepncp(o,loc,int)}
upewnić się: _: : perf: subj{np(str)} + {prepncp(o,loc,że)}
upewnić się: _: : perf: subj{np(str)} + {prepncp(w,loc,int)}
upewnić się: _: : perf: subj{np(str)} + {prepncp(w,loc,że)}
upewnić się: _: : perf: subj{np(str)} + {prepnp(co do,gen)}
upewnić się: _: : perf: subj{np(str)} + {prepnp(o,loc)}
upewnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
upewnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
upewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(co do,gen,że)}
upewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,że)}
upewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(w,loc,że)}
upewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
upewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)}
upewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
upić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
upić się: _: : perf: subj{np(str)} + {np(inst)}
upić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
upić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
upiec się: _: : perf: {np(dat)}
upiec się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
upiec się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
upiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
upiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
upiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
upierać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
upierać się: _: : imperf: subj{np(str)} + {cp(że)}
upierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)}
upierać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)} + {or}
upijać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
upijać się: _: : imperf: subj{np(str)} + {np(inst)}
upijać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
upijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
upilnować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
upilnować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upilnować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
upilnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uplasować się: _: : perf: subj{np(str)} + {xp(locat)}
uplasować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upłynąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
upłynąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
upłynąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
upłynąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wśród,gen)}
upłynąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
upłynąć: _: : perf: subj{np(str)} + {np(str)}
upłynąć: _: : perf: subj{np(str)} + {xp(temp)}
upływać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
upływać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
upływać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
upływać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wśród,gen)}
upływać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
upływać: _: : imperf: subj{np(str)} + {xp(temp)}
upodabniać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
upodabniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
upodabniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
upodabniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
upodabniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
upodabniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
upodobać: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
upodobać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
upodobać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {lexnp(dat,_,'siebie',natr)}
upodobniać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
upodobniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
upodobniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
upodobniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
upodobniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
upodobniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
upodobnić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
upodobnić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
upodobnić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
upodobnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
upodobnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
upodobnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
upoić się: _: : perf: subj{np(str)} + {cp(int)}
upoić się: _: : perf: subj{np(str)} + {cp(że)}
upoić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
upoić się: _: : perf: subj{np(str)} + {or}
upoić: _: : perf: subj{cp(int)} + {np(str)}
upoić: _: : perf: subj{cp(że)} + {np(str)}
upoić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
upoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
upokarzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
upokarzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
upokarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
upokarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
upokorzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
upokorzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
upokorzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
upokorzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
upolitycznić się: _: : perf: subj{np(str)}
upolitycznić: _: : perf: subj{np(str)} + obj{np(str)}
upolować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
upolować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
upominać się: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
upominać się: _: : imperf: subj{np(str)} + {or}
upominać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
upominać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
upominać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
upominać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {or}
upomnieć się: _: : perf: subj{np(str)} + {cp(że)}
upomnieć się: _: : perf: subj{np(str)} + {prepncp(o,acc,żeby)}
upomnieć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(u,gen)} + {or}
upomnieć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(żeby)}
upomnieć się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
upomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
upomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
upomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
upomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(za,acc,że)}
uporać się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że); prepncp(z,inst,żeby)}
uporządkować się: _: : perf: subj{np(str)}
uporządkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
upośledzać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
upośledzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
upośledzić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
upośledzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
upoważniać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upoważniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
upoważniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
upoważnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upoważnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
upoważnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
upowszechniać się: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
upowszechniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upowszechnić się: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
upowszechnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upraszać: _: : imperf: subj{np(str)} + {infp(_)}
upraszać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(u,gen)}
upraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
upraszczać się: _: : imperf: subj{np(str)}
upraszczać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
upraszczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
uprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uprawić: _: : perf: subj{np(str)} + obj{np(str)}
uprawniać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
uprawniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
uprawnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
uprawnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
uprawomocnić się: _: : perf: subj{np(str)}
uprawomocnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uprosić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
uprosić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
uprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
uprościć się: _: : perf: subj{np(str)}
uprościć: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
uprościć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
uprzeć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
uprzeć się: _: : perf: subj{np(str)} + {cp(że)}
uprzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)} + {or}
uprzeć się: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)} + {or}
uprzedzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,żeby)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
uprzedzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,żeby)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
uprzemysłowić się: _: : perf: subj{np(str)}
uprzemysłowić: _: : perf: subj{np(str)} + obj{np(str)}
uprzykrzać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uprzykrzać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uprzykrzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(str)}
uprzykrzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
uprzykrzyć się: _: : perf: subj,controllee{infp(imperf)} + controller{np(dat)}
uprzykrzyć się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uprzykrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uprzykrzyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(str)}
uprzykrzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
uprzytomniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(int)}
uprzytomniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(że)}
uprzytomniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uprzytomniać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
uprzytomniać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
uprzytomniać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
uprzytomniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uprzytomnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(int)}
uprzytomnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(że)}
uprzytomnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uprzytomnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
uprzytomnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
uprzytomnić: _: : perf: subj{np(str)} + {np(dat)} + {or}
uprzytomnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
upstrzyć się: _: : perf: subj{np(str)} + {np(inst)}
upstrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
upuszczać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
upuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
upuścić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
upuścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
upychać się: _: : imperf: subj{np(str)} + {xp(adl)}
upychać się: _: : imperf: subj{np(str)} + {xp(locat)}
upychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
upychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
uradować się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
uradować się: _: : perf: subj{np(str)} + {cp(że)}
uradować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uradować się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
uradować się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
uradować: _: : perf: subj{cp(gdy)} + {np(str)}
uradować: _: : perf: subj{cp(int)} + {np(str)}
uradować: _: : perf: subj{cp(jak)} + {np(str)}
uradować: _: : perf: subj{cp(jeśli)} + {np(str)}
uradować: _: : perf: subj{cp(kiedy)} + {np(str)}
uradować: _: : perf: subj{cp(że)} + {np(str)}
uradować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
uradować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(str,int)} + {np(str)}
uratować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
uratować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
uratować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
uratować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
uratować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
uratować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(przed,inst)}
uratować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
urazić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
urazić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
urazić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
urazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
urazić: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
urazić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
urażać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
urażać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
urażać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
urażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
urażać: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {refl}
urażać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
urealniać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
urealniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
urealnić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
urealnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
uregulować się: _: : perf: subj{np(str)}
uregulować: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'rachunek',atr)} + {prepnp(z,inst)}
uregulować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urodzić się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
urodzić się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
urodzić się: _: : perf: subj{np(str)} + {np(dat)}
urodzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
urodzić się: _: : perf: subj{np(str)} + {xp(locat)}
urodzić się: _: : perf: subj{np(str)} + {xp(temp)}
urodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uroić się: _: : perf: subj{cp(że)} + {np(dat)}
uroić się: _: : perf: subj{np(str)} + {np(dat)}
uroić: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
uroić: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
urozmaicać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urozmaicać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
urozmaicić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urozmaicić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
uruchamiać się: _: : imperf: subj{np(str)} + {np(dat)}
uruchamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uruchomić się: _: : perf: subj{np(str)} + {np(dat)}
uruchomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urwać się: _: : perf: subj{E}
urwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urwać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
urwać się: _: : perf: subj{np(str)} + {xp(locat)}
urwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
urwać: _: : perf: subj{np(str)} + {or}
urywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
urywać się: _: : imperf: subj{np(str)} + {xp(locat)}
urywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
urywać: _: : imperf: subj{np(str)} + {or}
urządzać się: _: : imperf: subj{np(str)} + {xp(locat)}
urządzać: _: : imperf: subj{np(str)} + {np(str)}
urządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
urządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
urządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
urządzić się: _: : perf: subj{np(str)} + {xp(locat)}
urządzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
urządzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urządzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
urządzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
urządzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
urzec: _: : perf: subj{cp(int)} + {np(str)}
urzec: _: : perf: subj{cp(że)} + {np(str)}
urzec: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
urzec: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
urzeczywistniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
urzeczywistniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
urzeczywistniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
urzeczywistnić się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
urzeczywistnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
urzeczywistnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
urzekać: _: : imperf: subj{cp(int)} + {np(str)}
urzekać: _: : imperf: subj{cp(że)} + {np(str)}
urzekać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
urzekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
urzędować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
usadawiać się: _: : imperf: subj{np(str)} + {xp(locat)}
usadawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
usadowić się: _: : perf: subj{np(str)} + {xp(locat)}
usadowić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
usadzać się: _: : imperf: subj{np(str)} + {xp(locat)}
usadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
usadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
usadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
usadzić się: _: : perf: subj{np(str)} + {xp(locat)}
usadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
usadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
usadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
usamodzielniać się: _: : imperf: subj{np(str)} + {advp(misc)}
usamodzielniać się: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
usamodzielniać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
usamodzielniać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
usamodzielnić się: _: : perf: subj{np(str)} + {advp(misc)}
usamodzielnić się: _: : perf: subj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
usamodzielnić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
usamodzielnić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
usankcjonować: _: : perf: subj{np(str)} + obj{cp(że)}
usankcjonować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
usatysfakcjonować: _: : perf: subj{cp(int)} + {np(str)}
usatysfakcjonować: _: : perf: subj{cp(jak)} + {np(str)}
usatysfakcjonować: _: : perf: subj{cp(jeśli)} + {np(str)}
usatysfakcjonować: _: : perf: subj{cp(że)} + {np(str)}
usatysfakcjonować: _: : perf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,że)} + {np(str)}
usatysfakcjonować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uschnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
uschnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
usiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
usidlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
usiłować: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
uskarżać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int); cp(że)}
uskarżać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
uskarżać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
uskarżać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int); cp(że)}
uskarżać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {or}
uskarżać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
uskarżać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
uskarżać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
uskarżać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {or}
uskrzydlać się: _: : imperf: subj{np(str)}
uskrzydlać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
uskrzydlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uskrzydlić się: _: : perf: subj{np(str)}
uskrzydlić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
uskrzydlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
usłać się: _: : perf: subj{np(str)} + {np(inst)}
usłać się: _: : perf: subj{np(str)} + {xp(locat)}
usłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
usłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
usłyszeć: _: : perf: subj{np(str)} + {cp(int)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: : perf: subj{np(str)} + {cp(jakoby)}
usłyszeć: _: : perf: subj{np(str)} + {cp(jak)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: : perf: subj{np(str)} + {cp(żeby2)}
usłyszeć: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: : perf: subj{np(str)} + {np(str); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(od,gen)}
usłyszeć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(jak); cp(że); ncp(str,że)} + {np(inst)}
usłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
usłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(jak)}
usłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
usłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {or}
usłyszeć: _: : perf: subj{np(str)} + {refl}
usmażyć się: _: : perf: subj{np(str)} + {advp(misc)}
usmażyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
usmażyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
usmażyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
usmażyć się: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(locat)}
usmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
usmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
usmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
usmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
usmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
usnąć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
usnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
usnąć: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
usnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
usnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
uspokajać się: _: : imperf: subj{np(str)} + {cp(że)}
uspokajać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
uspokajać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
uspokajać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
uspokajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
uspokajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uspokajać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
uspokoić się: _: : perf: subj{np(str)} + {cp(że)}
uspokoić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
uspokoić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
uspokoić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
uspokoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uspokoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uspokoić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
uspołecznić się: _: : perf: subj{np(str)}
uspołecznić: _: : perf: subj{np(str)} + obj{np(str)}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
usprawiedliwiać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
usprawiedliwiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
usprawiedliwiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
usprawiedliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
usprawiedliwić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
usprawiedliwić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
usprawiedliwić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
usprawiedliwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
usprawiedliwić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
usprawiedliwić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
usprawiedliwić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
usprawiedliwić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
usprawiedliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
usprawniać się: _: : imperf: subj{np(str)}
usprawniać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(dat)}
usprawniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
usprawnić się: _: : perf: subj{np(str)}
usprawnić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(dat)}
usprawnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
ustabilizować się: _: : perf: subj{np(str)}
ustabilizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ustać się: _: : perf: subj{np(str)}
ustać: _: : perf: subj{np(str)} + obj{np(str)}
ustać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
ustalać się: _: : imperf: subj{np(str)}
ustalać: _: : imperf: subj{np(str)} + obj{cp(int); cp(że)} + {prepnp(z,inst)}
ustalać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(z,inst)}
ustalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,inst)}
ustalić się: _: : perf: subj{np(str)}
ustalić: _: : perf: subj{np(str)} + obj{cp(int); cp(że)} + {prepnp(z,inst)}
ustalić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(z,inst)}
ustalić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,inst)}
ustanawiać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
ustanawiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
ustanawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ustanowić: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
ustanowić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
ustanowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ustatkować się: _: : perf: subj{np(str)}
ustawać: _: : imperf: subj{np(str)} + obj{np(str)}
ustawać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
ustąpić: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
ustąpić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ustąpić: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
ustąpić: _: : perf: subj{np(str)} + {prepnp(od,gen)}
ustąpić: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
ustąpić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {comprepnp(na rzecz)}
ustępować: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
ustępować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); prepnp(w,loc); prepncp(w,loc,że); advp(misc); preplexnp(pod,inst,_,'wzgląd',atr)}
ustępować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
ustępować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
ustępować: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
ustępować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
ustępować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {comprepnp(na rzecz)}
ustosunkować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
ustosunkować się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
ustosunkować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
ustosunkowywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
ustosunkowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
ustosunkowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
ustrzec się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
ustrzec się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
ustrzec się: _: : perf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
ustrzec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
ustrzec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
ustrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ustrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
usunąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
usunąć się: _: : perf: subj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)}
usunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
usunąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)}
usuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
usuwać się: _: : imperf: subj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)}
usuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
usuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)}
usychać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
usychać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
usypać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)}
usypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
usypiać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
usypiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
usypiać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
usypiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
usypiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
usypiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
usypiać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
usypiać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
usypywać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(abl)}
usypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
usystematyzować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
usystematyzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
usytuować się: _: : perf: subj{np(str)} + {xp(locat)}
usytuować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uszczegóławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uszczegóławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
uszczegółowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uszczegółowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
uszczelniać się: _: : imperf: subj{np(str)} + {np(dat)}
uszczelniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uszczelnić się: _: : perf: subj{np(str)} + {np(dat)}
uszczelnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uszczknąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
uszczknąć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(dla,gen)} + {prepnp(od,gen)}
uszczuplać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
uszczuplać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
uszczuplić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
uszczuplić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
uszkodzić się: _: : perf: subj{np(str)} + {np(dat)}
uszkodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uszlachetniać się: _: : imperf: subj{np(str)}
uszlachetniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uszlachetnić się: _: : perf: subj{np(str)}
uszlachetnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
usztywniać się: _: : imperf: subj{np(str)} + {np(dat)}
usztywniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
usztywniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
usztywniać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
usztywniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
usztywnić się: _: : perf: subj{np(str)} + {np(dat)}
usztywnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
usztywnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
usztywnić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
usztywnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
uściskać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
uściskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uściskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uścisnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
uścisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uścisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
uściślać się: _: : imperf: subj{np(str)}
uściślać: _: : imperf: subj{np(str)} + obj{cp(int)}
uściślać: _: : imperf: subj{np(str)} + obj{cp(że)}
uściślać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
uściślać: _: : imperf: subj{np(str)} + {or}
uściślić się: _: : perf: subj{np(str)}
uściślić: _: : perf: subj{np(str)} + obj{cp(int)}
uściślić: _: : perf: subj{np(str)} + obj{cp(że)}
uściślić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
uściślić: _: : perf: subj{np(str)} + {or}
uśmiechać się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
uśmiechać się: _: : imperf: subj{cp(żeby)} + {np(dat)}
uśmiechać się: _: : imperf: subj{np(str)} + {cp(że)}
uśmiechać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
uśmiechać się: _: : imperf: subj{np(str)} + {or}
uśmiechać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uśmiechać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
uśmiechnąć się: _: : perf: subj{np(str)} + {cp(że)}
uśmiechnąć się: _: : perf: subj{np(str)} + {or}
uśmiechnąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uśmiechnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
uśmiercać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
uśmiercać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uśmiercić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
uśmiercić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uśpić się: _: : perf: subj{np(str)}
uśpić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
uśpić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
uśpić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uśpić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uświadamiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
uświadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uświadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uświadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int); cp(że)}
uświadamiać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uświadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
uświadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
uświadomić: _: : perf: subj{np(str)} + {np(dat)} + {or}
uświadomić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uświadomić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uświadomić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int); cp(że)}
uświadomić: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uświadomić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
uświadomić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
uświetniać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
uświetniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uświetnić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
uświetnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uświęcać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
uświęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uświęcić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
uświęcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
utajniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
utajniać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
utajniać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
utajnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
utajnić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
utajnić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
utkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
utkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
utkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
utkać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
utkać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
utknąć: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
utłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
utonąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
utopić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
utopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
utorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
utożsamiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
utożsamiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
utożsamić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
utożsamić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
utracić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
utrącać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
utrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
utrącić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
utrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
utrudniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
utrudniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
utrudnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
utrudnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
utrwalić się: _: : perf: subj{cp(int)} + {np(dat)} + {prepnp(w,loc)}
utrwalić się: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
utrwalić się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
utrwalić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
utrwalić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {cp(że)}
utrwalić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
utrwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
utrwalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
utrwalić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
utrwalić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(jak)}
utrząść: _: : perf: subj{np(str)} + obj{np(str)}
utrzeć się: _: : perf: subj{cp(że)}
utrzeć się: _: : perf: subj{cp(żeby)}
utrzeć się: _: : perf: subj{infp(imperf)}
utrzeć się: _: : perf: subj{np(str)}
utrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {lexnp(gen,sg,'nos',natr)}
utrzeć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
utrzeć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
utrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,inst)}
utrzymać się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
utrzymać się: _: : perf: subj{np(str)} + {xp(locat)}
utrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
utrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
utrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
utrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utrzymać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
utrzymywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
utrzymywać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
utrzymywać się: _: : imperf: subj{np(str)} + {xp(locat)}
utrzymywać: _: : imperf: subj{np(str)} + {cp(jakoby)}
utrzymywać: _: : imperf: subj{np(str)} + {cp(że)}
utrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
utrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
utrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
utrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utrzymywać: _: : imperf: subj{np(str)} + {or}
utrzymywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
utwardzać się: _: : imperf: subj{np(str)}
utwardzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
utwardzić się: _: : perf: subj{np(str)}
utwardzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
utwierdzać się: _: : imperf: subj{np(str)} + {cp(int)}
utwierdzać się: _: : imperf: subj{np(str)} + {cp(że)}
utwierdzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {cp(że)}
utwierdzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
utwierdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzić się: _: : perf: subj{np(str)} + {cp(int)}
utwierdzić się: _: : perf: subj{np(str)} + {cp(że)}
utwierdzić się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {cp(że)}
utwierdzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
utwierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
utworzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
utworzyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
utworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
utyć: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
utyć: _: : perf: subj{np(str)} + {np(str)}
utyć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
utyć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
utyć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
utyć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
utykać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
utykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
utykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
utykać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utykać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
utykać: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
uwalniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
uwalniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
uwalniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(spod,gen)} + {refl}
uwalniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uwalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
uwalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spod,gen)}
uwalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uwalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
uwarunkować się: _: : perf: subj{np(str)}
uwarunkować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
uwarunkować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
uwarunkować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)} + {refl}
uwarunkować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
uwarunkować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
uwarunkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uwarunkować: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {refl}
uważać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uważać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uważać: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
uważać: _: : imperf: subj{np(str)} + controller{infp(_)} + controllee{prepadjp(za,acc)}
uważać: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
uważać: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)}
uważać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
uważać: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepadjp(za,acc)}
uważać: _: : imperf: subj{np(str)} + obj{cp(że)}
uważać: _: : imperf: subj{np(str)} + {or}
uważać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(czy)}
uważać: _: : imperf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,int); prepncp(na,acc,żeby)}
uważać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
uważać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
uwiązać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
uwiązać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
uwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
uwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
uwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
uwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
uwidaczniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uwidaczniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
uwidaczniać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
uwidaczniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
uwidaczniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uwidocznić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uwidocznić się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
uwidocznić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
uwidocznić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
uwidocznić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uwieczniać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
uwieczniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwieczniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uwiecznić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
uwiecznić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwiecznić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uwielbiać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
uwielbiać: _: : imperf: subj{np(str)} + obj{np(str); cp(gdy); cp(jak); cp(kiedy); ncp(str,że)} + {prepnp(w,loc)}
uwielbiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
uwieńczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uwierzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(gdy)}
uwierzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(kiedy)}
uwierzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby2)}
uwierzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'słowa',natr)}
uwierzyć: _: : perf: subj{np(str)} + {np(dat); prepnp(w,acc)}
uwierzyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc); cp(że); prepncp(w,acc,że); prepncp(w,acc,żeby2)}
uwierzytelniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwierzytelnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwieść: _: : perf: subj{cp(że)} + {np(str)}
uwieść: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
uwieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uwieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uwięzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwięzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(locat)}
uwięznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uwięznąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
uwijać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
uwijać się: _: : imperf: subj{np(str)} + {xp(locat)}
uwikłać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
uwikłać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
uwikłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uwinąć się: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
uwłaszczać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
uwłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
uwłaszczyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
uwłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
uwodzić: _: : imperf: subj{cp(że)} + {np(str)}
uwodzić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
uwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
uwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uwolnić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
uwolnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
uwolnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(spod,gen)} + {refl}
uwolnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uwolnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
uwolnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spod,gen)}
uwolnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uwolnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
uwrażliwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
uwrażliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
uwrażliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
uwrażliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
uwrażliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
uwrażliwić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
uwrażliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
uwrażliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
uwrażliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
uwrażliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
uwspółcześniać się: _: : imperf: subj{np(str)}
uwspółcześniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwspółcześnić się: _: : perf: subj{np(str)}
uwspółcześnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwzględniać: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,inst)}
uwzględnić: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,inst)}
uwziąć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
uwziąć się: _: : perf: subj{np(str)} + {cp(że)}
uwziąć się: _: : perf: subj{np(str)} + {cp(żeby)}
uwziąć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uzależniać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzależniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzależniać: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int)} + {cp(int)}
uzależnić się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzależnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzależnić: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int)} + {cp(int)}
uzasadniać: _: : imperf: subj{np(str)} + {cp(int)}
uzasadniać: _: : imperf: subj{np(str)} + {cp(że)}
uzasadniać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
uzasadniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,że)}
uzasadniać: _: : imperf: subj{np(str)} + {or}
uzasadnić: _: : perf: subj{np(str)} + {cp(int)}
uzasadnić: _: : perf: subj{np(str)} + {cp(że)}
uzasadnić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
uzasadnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,że)}
uzasadnić: _: : perf: subj{np(str)} + {or}
uzbierać się: _: : perf: subj{np(part)} + {np(dat)}
uzbierać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
uzbierać się: _: : perf: subj{np(str)} + {xp(locat)}
uzbierać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
uzbierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uzbrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
uzbrajać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
uzbroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
uzbroić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
uzdatniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
uzdatnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
uzdrawiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uzdrawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uzdrowić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uzdrowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uzgadniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(z,inst)}
uzgadniać: _: : imperf: subj{np(str)} + obj{ncp(str,int)} + {prepnp(z,inst)}
uzgadniać: _: : imperf: subj{np(str)} + obj{np(str); cp(int)} + {prepnp(z,inst)}
uzgadniać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {ncp(str,że)}
uzgodnić: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(z,inst)}
uzgodnić: _: : perf: subj{np(str)} + obj{ncp(str,że)} + {prepnp(z,inst)}
uzgodnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uzgodnić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
uzgodnić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {ncp(str,int)}
uznać: _: : perf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
uznać: _: : perf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{adjp(inst)}
uznać: _: : perf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{prepadjp(za,acc)}
uznać: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
uznać: _: : perf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uznać: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
uznać: _: : perf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uznać: _: : perf: subj{np(str)} + controller{cp(że)} + controllee{prepadjp(za,acc)}
uznać: _: : perf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(za,acc)}
uznać: _: : perf: subj{np(str)} + {cp(int)}
uznać: _: : perf: subj{np(str)} + {cp(żeby)}
uznać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uznać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uznać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
uznać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
uznać: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepnp(za,acc)}
uznać: _: : perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
uznać: _: : perf: subj{np(str)} + obj{cp(że)}
uznawać: _: : imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
uznawać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
uznawać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uznawać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uznawać: _: : imperf: subj,controller{np(str)} + obj,controllee,controller2{infp(_)} + controllee2{prepnp(za,acc)}
uznawać: _: : imperf: subj{np(str)} + controller{cp(że)} + controllee{prepadjp(jako,str)}
uznawać: _: : imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(jako,str)}
uznawać: _: : imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(za,acc)}
uznawać: _: : imperf: subj{np(str)} + {cp(int)}
uznawać: _: : imperf: subj{np(str)} + {cp(żeby)}
uznawać: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
uznawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uznawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uznawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
uznawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
uznawać: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepnp(za,acc)}
uznawać: _: : imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
uznawać: _: : imperf: subj{np(str)} + obj{cp(że)}
uzupełniać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
uzupełniać: _: : imperf: subj{np(str)} + {cp(że)}
uzupełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uzupełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzupełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
uzupełniać: _: : imperf: subj{np(str)} + {or}
uzupełnić: _: : perf: subj{np(str)} + {cp(że)}
uzupełnić: _: : perf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uzupełnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzupełnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
uzupełnić: _: : perf: subj{np(str)} + {or}
uzyskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uzyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
użalać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int); cp(że)}
użalać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
użalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
użalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
użalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
użalać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
użalać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
użalać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
użalać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(przed,inst)}
użalać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int); cp(że)}
użalać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
użyczać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(do,gen)}
użyczać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(na,acc)}
użyczać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(pod,acc)}
użyczać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(dla,gen)}
użyczyć: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(do,gen)}
użyczyć: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(na,acc)}
użyczyć: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(pod,acc)}
użyczyć: _: : perf: subj{np(str)} + obj{np(gen)} + {prepnp(dla,gen)}
użyć: _: : perf: subj{np(str)} + obj,controller{np(gen)} + controllee{prepnp(jako,str)}
użyć: _: : perf: subj{np(str)} + obj{np(gen)} + {prepncp(do,gen,żeby)}
użyć: _: : perf: subj{np(str)} + obj{np(gen)} + {prepnp(dla,gen)}
użyć: _: : perf: subj{np(str)} + obj{np(gen)} + {prepnp(do,gen)}
użyć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
użydowić: _: : perf: subj{np(str)} + obj{np(str)}
użytkować: _: : imperf: subj{np(str)} + obj{np(str)}
używać: _: : imperf: subj{np(str)} + obj,controller{np(gen)} + controllee{prepnp(jako,str)}
używać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepncp(do,gen,żeby)}
używać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(dla,gen)}
używać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(do,gen)}
używać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
wabić się: _: : imperf: subj,controller{np(str)} + controllee{np(nom)}
wabić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
wabić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(adl)}
wabić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wahać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
wahać się: _: : imperf: subj{np(str)} + {cp(int)}
wahać się: _: : imperf: subj{np(str)} + {cp(żeby)}
wahać się: _: : imperf: subj{np(str)} + {prepncp(nad,inst,żeby)}
wahać się: _: : imperf: subj{np(str)} + {prepncp(przed,inst,żeby2)}
wahać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wahać się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
wahać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
wahać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
wahać: _: : imperf: subj{np(str)} + {np(inst)}
walać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
walać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
walać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
walczyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat); prepnp(z,inst)}
walczyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
walczyć: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(przeciw,dat); prepnp(z,inst)}
walczyć: _: : imperf: subj{np(str)} + {prepnp(pod,inst)} + {prepnp(przeciw,dat); prepnp(z,inst)}
walczyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
walczyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
walić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
walić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
walić się: _: : imperf: subj{np(str)} + {xp(adl)}
walić: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)}
walić: _: : imperf: {np(dat)} + {xp(locat)}
walić: _: : imperf: subj{cp(int)} + {np(str)}
walić: _: : imperf: subj{cp(że)} + {np(str)}
walić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
walić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
walić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
walić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
walić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
walić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
walić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
walić: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
walić: _: : imperf: subj{np(str)} + obj{np(str)}
walić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
walić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
walić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
walić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
walić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
walić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(za,inst)}
walić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
walka: : : : {possp} + {prepnp(na,acc)} + {prepnp(o,acc); prepnp(przeciw,dat); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {prepnp(z,inst)} + {xp(locat)}
walka: : : : {possp} + {prepnp(z,inst)} + {cp(żeby)}
walka: : : : {prepnp(między,inst)} + {prepnp(na,acc)} + {prepnp(o,acc)} + {xp(locat)}
waloryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wałęsać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wałęsać się: _: : imperf: subj{np(str)} + {xp(locat)}
warczeć: _: : imperf: subj{np(str)} + {np(inst)}
warczeć: _: : imperf: subj{np(str)} + {np(str)}
warczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
warczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
warczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
warczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
warczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
warczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
warczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
warczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
warczeć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
wariować: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
wariować: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
wariować: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wariować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
warknąć: _: : perf: subj{np(str)} + {np(inst)}
warknąć: _: : perf: subj{np(str)} + {np(str)}
warknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
warknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
warknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
warknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
warknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
warknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
warknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
warknąć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
warto: _: : imperf: {cp(żeby)}
warto: _: : imperf: {infp(_)}
wartościować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
warunkować się: _: : imperf: subj{np(str)}
warunkować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
warunkować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)} + {refl}
warunkować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
warunkować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
warunkować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
warunkować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {refl}
ważyć się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
ważyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
ważyć się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
ważyć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ważyć: _: : imperf: subj{np(str)} + {np(str)}
ważyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ważyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ważyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ważyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ważyć: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)}
ważyć: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
wąchać: _: : imperf: subj{np(str)} + {cp(int)} + {refl}
wąchać: _: : imperf: subj{np(str)} + {lexnp(str,pl,'kwiatek',natr)} + {preplexnp(od,gen,sg,'spód',natr)}
wąchać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
wąchać: _: : imperf: subj{np(str)} + obj{np(str); cp(int)} + {np(dat)}
wątpić: _: : imperf: subj{np(str)} + {cp(int)}
wątpić: _: : imperf: subj{np(str)} + {cp(że)}
wątpić: _: : imperf: subj{np(str)} + {cp(żeby)}
wątpić: _: : imperf: subj{np(str)} + {or}
wątpić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
wątpić: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wbić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wbić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wbić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
wbić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
wbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
wbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wbijać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wbijać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wbijać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
wbijać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
wbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
wbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wbudować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wbudować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wchłaniać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wchłaniać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchłaniać się: _: : imperf: subj{np(str)} + {xp(locat)}
wchłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wchłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wchłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchłonąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wchłonąć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchłonąć się: _: : perf: subj{np(str)} + {xp(locat)}
wchłonąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wchłonąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wchłonąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchodzić: _: : imperf: subj{cp(żeby2)} + {np(dat)} + {prepnp(w,acc)}
wchodzić: _: : imperf: subj{cp(żeby2)} + {prepnp(w,acc)}
wchodzić: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
wchodzić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wchodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wchodzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wchodzić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wchodzić: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wchodzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
wchodzić: _: : imperf: subj{np(str)} + {xp(temp)} + {preplexnp(w,acc,sg,'życie',natr)}
wciąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wciąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wciąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wciąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wciąć: _: : perf: {np(dat)} + {np(str)}
wciąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wciągać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wciągać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wciągać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
wciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
wciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wciągnąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wciągnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wciągnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
wciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
wciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wcielać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wcielać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wcielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wcielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wcielić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wcielić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wcielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wcielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wcierać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wcierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wcinać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wcinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wciskać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wciskać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',natr)}
wciskać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'gaz',natr)} + {preplexnp(do,gen,sg,'decha',natr)}
wciskać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',natr)}
wciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wcisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wcisnąć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',natr)}
wcisnąć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'gaz',natr)} + {preplexnp(do,gen,sg,'decha',natr)}
wcisnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',natr)}
wcisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wczuć się: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wczuwać się: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wczytać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wczytać się: _: : perf: subj{np(str)} + {xp(adl)}
wczytać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wczytywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wczytywać się: _: : imperf: subj{np(str)} + {xp(adl)}
wczytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wdać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wdawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wdepnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wdepnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wdepnąć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wdeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wdeptać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wdeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wdeptywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wdowa: : : : {fixed('czarna')}
wdowa: : : : {fixed('słomiana')}
wdowa: : : : {prepnp(po,loc)}
wdrapać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wdrapywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wdrażać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wdrażać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wdrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wdrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wdrożyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wdrożyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wdrożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wdrożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wdychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wdychać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wdychać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
wdzierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)}
wdzierać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wdzierać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wdzięczyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wdzięczyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
wdzięczyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
wdzięczyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(w,loc)}
wegetować: _: : imperf: subj{np(str)} + {xp(locat)}
wejść: _: : perf: subj{cp(żeby)} + {np(dat)} + {prepnp(w,acc)}
wejść: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
wejść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wejść: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wejść: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wejść: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
wejść: _: : perf: subj{np(str)} + {xp(temp)} + {preplexnp(w,acc,sg,'życie',natr)}
wepchać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wepchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wepchnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
werbować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
werbować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
werbować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
werbować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wertować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
weryfikować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
weryfikować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
weryfikować: _: : imperf: subj{np(str)} + obj{cp(int)}
weryfikować: _: : imperf: subj{np(str)} + obj{cp(że)}
weryfikować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
weryfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
weselić się: _: : imperf: subj{np(str)} + {cp(że)}
weselić się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
weselić się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
weselić: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
wesprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wesprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
wesprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wesprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wesprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wesprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
westchnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
westchnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
westchnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wetknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wetować: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)} + {lexnp(dat,_,'siebie',natr)}
wetować: _: : imperf: subj{np(str)} + obj{np(str)}
wetrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wezwać: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
wezwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wezwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wezwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {xp(adl)}
wezwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
wezwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
wędkować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wędrować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
wędrować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wędrować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wędrować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wędrować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wędrować: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
wędrować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wędzić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wędzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
węszyć: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
węszyć: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
węszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
węszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
węszyć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
wgniatać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wgniatać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wgniatać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
wgniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wgnieść się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wgnieść się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wgnieść się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
wgnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wgryzać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wgryzać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wgryźć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wgryźć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wiać: _: : imperf: {np(inst)} + {prepnp(na,acc)}
wiać: _: : imperf: {np(inst)} + {prepnp(od,gen)}
wiać: _: : imperf: {np(inst)} + {xp(abl)}
wiać: _: : imperf: {np(inst)} + {xp(adl)}
wiać: _: : imperf: {np(inst)} + {xp(perl)}
wiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
wiać: _: : imperf: subj{np(str)} + obj{np(str)}
wiać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wiać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wiać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
wiać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wiać: _: : imperf: subj{np(str)} + {xp(perl)}
wiadomo: _: : imperf: {np(dat)} + {comprepnp(w kwestii)} + {nonch}
wiadomo: _: : imperf: {np(dat)} + {comprepnp(w sprawie)} + {nonch}
wiadomo: _: : imperf: {np(dat)} + {cp(jakoby); cp(żeby)} + {nonch}
wiadomo: _: : imperf: {np(dat)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
wiadomo: _: : imperf: {prepnp(z,inst)} + {nonch} + {fixed('nigdy')}
wiara: : : : {np(dat)} + {possp}
wiara: : : : {possp} + {cp(jakoby)}
wiara: : : : {possp} + {cp(że)}
wiara: : : : {possp} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,jakoby); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wiara: : : : {preplexnp(na,acc,sg,'słowo',natr)}
wiązać się: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wiązać się: _: : imperf: subj{np(str)} + {np(inst)}
wiązać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wiązać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wiązać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wiązać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wiązać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wibrować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wibrować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wibrować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wibrować: _: : imperf: subj{np(str)} + {np(inst)}
wichrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
wichrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wichrzyć: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
wichrzyć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
wichrzyć: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)}
wić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wić się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wić się: _: : imperf: subj{np(str)} + {xp(locat)}
wić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
widać: _: : imperf: {cp(int); cp(że)}
widać: _: : imperf: {cp(jak)}
widać: _: : imperf: {np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int)}
widać: _: : imperf: {np(str)} + {prepnp(z,gen)}
widać: _: : imperf: {np(str)} + {xp(locat)}
widać: _: : imperf: {prepnp(po,loc)} + {cp(int)}
widać: _: : imperf: {prepnp(po,loc)} + {cp(żeby2)}
widać: _: : imperf: {prepnp(po,loc); prepncp(po,loc,int)} + {cp(że)}
widać: _: : imperf: {prepnp(z,gen)} + {cp(int)}
widać: _: : imperf: {prepnp(z,gen)} + {cp(że)}
widnieć: _: : imperf: subj{E}
widnieć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
widnieć: _: : imperf: subj{np(str)} + {xp(locat)}
widok: : : : {np(gen)} + {possp}
widok: : : : {np(gen)} + {xp(locat)}
widok: : : : {possp} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
widok: : : : {xp(abl)} + {xp(adl)}
widywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
widywać: _: : imperf: subj{np(str)} + {cp(że)}
widywać: _: : imperf: subj{np(str)} + {cp(żeby2)}
widywać: _: : imperf: subj{np(str)} + {cp(żeby2)} + {preplexnp(na,acc,pl,'oko',batr)}
widywać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'oko',batr)}
widywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(str)}
widywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
widywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {preplexnp(na,acc,pl,'oko',batr)}
widywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {xp(locat)}
widywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
widzieć się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
widzieć się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
widzieć się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
widzieć się: _: : imperf: subj{cp(jakoby)} + {np(dat)}
widzieć się: _: : imperf: subj{cp(żeby)} + {np(dat)}
widzieć się: _: : imperf: subj{cp(że)} + {np(dat)}
widzieć się: _: : imperf: subj{np(str)} + {np(dat)}
widzieć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
widzieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'potrzeba',atr)}
widzieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'powód',atr)}
widzieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'problem',atr)}
widzieć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'sens',atr)}
widzieć: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
widzieć: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
widzieć: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)}
widzieć: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{np(inst)}
widzieć: _: : imperf: subj{np(str)} + {cp(gdy)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + {cp(jakoby)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + {cp(kiedy)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + {lexnp(inst,pl,'oko',ratr)} + {refl}
widzieć: _: : imperf: subj{np(str)} + {np(str); cp(int); cp(jak); cp(że); cp(żeby2); ncp(str,int); ncp(str,jak); ncp(str,że)}
widzieć: _: : imperf: subj{np(str)} + {np(str); ncp(str,że)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{xp(mod)}
widzieć: _: : imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{xp(mod)}
widzieć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
widzieć: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
widzieć: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
widzieć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
widzieć: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
wiecować: _: : imperf: subj{np(str)} + {xp(locat)}
wiedzieć: _: : imperf: subj{np(str)} + {cp(żeby2)} + {nonch}
wiedzieć: _: : imperf: subj{np(str)} + {ncp(str,int)}
wiedzieć: _: : imperf: subj{np(str)} + {np(str); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby2)}
wiedzieć: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
wiedzieć: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
wielbić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wielbić: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
wielbić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wieńczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wiercić się: _: : imperf: subj{np(str)} + {xp(locat)}
wiercić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {lexnp(str,sg,'dziura',natr)} + {preplexnp(w,str,sg,'brzuch',natr)}
wiercić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'dziura',natr)} + {preplexnp(w,str,sg,'brzuch',natr)}
wiercić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {lexnp(str,sg,'dziura',natr)} + {preplexnp(w,str,sg,'brzuch',natr)}
wiercić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wiercić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wiersz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(ku,dat)}
wiersz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
wiersz: : : : {adjp(agr)} + {possp} + {prepnp(dla,gen)} + {prepnp(przeciw,dat)}
wiersz: : : : {adjp(agr)} + {possp} + {prepnp(do,gen)}
wiersz: : : : {adjp(agr)} + {possp} + {prepnp(na,acc)}
wiersz: : : : {possp; prepnp(ku,dat)}
wiersz: : : : {prepnp(dla,gen); prepnp(o,loc)}
wierszować: _: : imperf: subj{np(str)} + obj{np(str)}
wierzgać: _: : imperf: subj{np(str)} + {np(inst)}
wierzgać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
wierzgać: _: : imperf: subj{np(str)} + {xp(adl)}
wierzgnąć: _: : perf: subj{np(str)} + {np(inst)}
wierzgnąć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
wierzgnąć: _: : perf: subj{np(str)} + {xp(adl)}
wierzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(gdy)}
wierzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(kiedy)}
wierzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby2)}
wierzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'słowo',natr)}
wierzyć: _: : imperf: subj{np(str)} + {np(dat); prepnp(w,acc)}
wierzyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc); cp(że); prepncp(w,acc,że); prepncp(w,acc,żeby2)}
wieszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wieszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)}
wieszać się: _: : imperf: subj{np(str)} + {np(gen)}
wieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wieszać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
wieścić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wieścić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wieścić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wieścić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wieść się: _: : imperf: controller{np(dat)} + controllee{xp(mod)} + {prepnp(w,loc)}
wieść: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wieść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wieść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wieść: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
wieść: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wietrzeć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wietrzeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wietrzeć: _: : imperf: subj{np(str)} + {xp(abl)}
wietrzyć się: _: : imperf: subj{np(str)} + {xp(locat)}
wietrzyć: _: : imperf: subj{np(str)} + {cp(int)}
wietrzyć: _: : imperf: subj{np(str)} + {cp(że)}
wietrzyć: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {xp(locat)}
wietrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wietrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
wietrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wieźć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
więdnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepnp(z,gen)}
więdnąć: _: : imperf: subj{np(str)} + {xp(locat)}
więzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
więzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(locat)}
więznąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
więznąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wikłać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wikłać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wikłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wina: : : : {comprepnp(po stronie)}
wina: : : : {possp} + {comprepnp(w stosunku do)}
wina: : : : {possp} + {comprepnp(z powodu)}
wina: : : : {possp} + {cp(że)}
wina: : : : {possp} + {prepnp(co do,gen)}
wina: : : : {possp} + {prepnp(przeciw,dat)}
wina: : : : {possp} + {prepnp(w,loc)}
wina: : : : {possp} + {prepnp(wobec,gen)}
wina: : : : {possp} + {prepnp(względem,gen)}
wina: : : : {possp} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
winić: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
winić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
winić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
winić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
winić: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {refl}
winić: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
winien: _: : imperf: subj,controller{E} + controllee{infp(_)}
winny: : : : {cp(że)}
winny: : : : {np(acc)} + {np(dat)} + {preplexnp(z,gen,sg,'tytuł',atr)}
winny: : : : {np(acc)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
winny: : : : {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
winny: : : : {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
wiosłować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wiosłować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
wiórkować się: _: : imperf: subj{np(str)}
wiórkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wirować: _: : imperf: {np(dat)} + {xp(locat)}
wirować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
wirować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wirować: _: : imperf: subj{np(str)} + {np(inst)}
wirować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wirować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wirować: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
wirować: _: : imperf: subj{np(str)} + {xp(adl)}
wisieć: _: : imperf: subj{cp(int)} + {np(dat)} + {np(inst)}
wisieć: _: : imperf: subj{cp(że)} + {np(dat)} + {np(inst)}
wisieć: _: : imperf: subj{cp(że)} + {prepnp(nad,inst)}
wisieć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
wisieć: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(nad,inst)}
wisieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
wisieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wisieć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wisieć: _: : imperf: subj{np(str)} + {preplexnp(u,gen,sg,'klamka',ratr)}
wisieć: _: : imperf: subj{np(str)} + {preplexnp(w,loc,sg,'powietrze',atr)}
wisieć: _: : imperf: subj{np(str)} + {preplexnp(w,loc,sg,'próżnia',atr)}
wisieć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wisieć: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wisieć: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
witać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
witać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
witać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
witać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wizja: : : : {np(gen); ncp(gen,int); ncp(gen,jakoby); ncp(gen,że)} + {possp}
wizja: : : : {possp} + {comprepnp(na temat)}
wizja: : : : {possp} + {comprepnp(w kwestii)}
wizja: : : : {possp} + {comprepnp(w sprawie)}
wizja: : : : {possp} + {cp(jakoby)}
wizja: : : : {possp} + {cp(że)}
wizja: : : : {possp} + {or}
wizja: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
wizja: : : : {possp} + {prepnp(dla,gen)}
wizja: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wizja: : : : {possp} + {xp(locat)}
wizytować: _: : imperf: subj{np(str)} + obj{np(str)}
wjechać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
wjechać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc)} + {xp(adl)}
wjechać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wjechać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'stół',atr)}
wjechać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wjeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
wjeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc)} + {xp(adl)}
wjeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wjeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'stół',atr)}
wjeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wkalkulować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,acc)}
wkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wkładać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'głowa',atr)}
wkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {lexnp(inst,sg,'łopata',natr)}
wkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(w,acc)}
wkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(między,acc,pl,'bajka',atr)}
wkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,żeby)}
wkłuć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(perl)}
wkłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wkłuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(perl)}
wkłuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wkraczać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wkraczać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wkraczać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wkraczać: _: : imperf: subj{np(str)} + {xp(adl)}
wkradać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wkradać się: _: : imperf: subj{np(str)} + {np(inst)} + {preplexnp(w,acc,pl,'łaska',ratr)}
wkradać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wkrajać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
wkraplać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wkraść się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wkraść się: _: : perf: subj{np(str)} + {np(inst)} + {preplexnp(w,acc,pl,'łaska',ratr)}
wkraść się: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wkręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wkręcać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
wkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wkręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wkręcać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wkręcać: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
wkręcić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wkręcić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wkręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wkręcić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wkręcić: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
wkroczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wkroczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wkroczyć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wkroczyć: _: : perf: subj{np(str)} + {xp(adl)}
wkroić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
wkroplić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wkurzać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
wkurzać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wkurzać się: _: : imperf: subj{np(str)} + {or}
wkurzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wkurzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wkurzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
wkurzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wkurzać: _: : imperf: subj{cp(gdy)} + {np(str)}
wkurzać: _: : imperf: subj{cp(int)} + {np(str)}
wkurzać: _: : imperf: subj{cp(jak)} + {np(str)}
wkurzać: _: : imperf: subj{cp(jeśli)} + {np(str)}
wkurzać: _: : imperf: subj{cp(kiedy)} + {np(str)}
wkurzać: _: : imperf: subj{cp(że)} + {np(str)}
wkurzać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
wkurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
wkurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
wkurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
wkurzyć się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
wkurzyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wkurzyć się: _: : perf: subj{np(str)} + {or}
wkurzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wkurzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wkurzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
wkurzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wkurzyć: _: : perf: subj{cp(gdy)} + {np(str)}
wkurzyć: _: : perf: subj{cp(int)} + {np(str)}
wkurzyć: _: : perf: subj{cp(jak)} + {np(str)}
wkurzyć: _: : perf: subj{cp(jeśli)} + {np(str)}
wkurzyć: _: : perf: subj{cp(kiedy)} + {np(str)}
wkurzyć: _: : perf: subj{cp(że)} + {np(str)}
wkurzyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
wkurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
wkurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wkurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
wlatywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wlatywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wlatywać: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
wlec się: _: : imperf: subj{np(str)} + {np(dat)}
wlec się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
wlec się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wlec się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wlec: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wlec: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wlec: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wlecieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wlecieć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wlecieć: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
wlepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wlepić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wleźć: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',atr)}
wleźć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',atr)}
wleźć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wleźć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wleźć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wleźć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wliczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wliczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wliczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wliczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
władać: _: : imperf: subj{np(str)} + obj{np(inst)}
władać: _: : imperf: subj{np(str)} + {xp(locat)}
władować się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
władować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
władować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
władować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
władować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
włamać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc)}
włamać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
włamać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
włamywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc)}
włamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
włamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
włazić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',atr)}
włazić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',atr)}
włazić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
włazić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
włazić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
włazić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
włączać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
włączać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {or}
włączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
włączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
włączyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
włączyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {or}
włączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
włączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
włożyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'głowa',atr)}
włożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
włożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {lexnp(inst,sg,'łopata',natr)}
włożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(w,acc)}
włożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
włożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
włożyć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(między,acc,pl,'bajka',atr)}
włożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,żeby)}
włóczyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
włóczyć się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
włóczyć się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
włóczyć się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
włóczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
włóczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(za,acc)}
włóczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
włóczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
włóczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wmaszerować: _: : perf: subj{np(str)} + {xp(adl)}
wmawiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wmawiać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wmawiać: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(w,acc)}
wmawiać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wmawiać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(w,acc)}
wmawiać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wmawiać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(w,acc)}
wmawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
wmawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,acc)}
wmawiać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {or}
wmieszać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wmieszać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wmieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wmieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wmontować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wmontować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wmontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wmontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wmontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wmontowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wmontowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wmontowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wmontowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wmontowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wmówić: _: : perf: subj{np(str)} + {np(dat)} + {or}
wmówić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wmówić: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(w,acc)}
wmówić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wmówić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(w,acc)}
wmówić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wmówić: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(w,acc)}
wmówić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
wmówić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,acc)}
wmówić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {or}
wmurować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wmurować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wmurowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wmurowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wmusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wmusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wmuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wmuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wnieść: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'obrady',atr)}
wnieść: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'adres',ratr)}
wnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)} + {xp(adl)}
wnieść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
wnieść: _: : perf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)} + {prepnp(w,loc)}
wnieść: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wnieść: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wnieść: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wnieść: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wnieść: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wnieść: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {nonch}
wnieść: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wnieść: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wnieść: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wnieść: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {nonch}
wnikać: _: : imperf: subj{np(str)} + {cp(int)}
wnikać: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wnikać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wniknąć: _: : perf: subj{np(str)} + {cp(int)}
wniknąć: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wniknąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wniosek: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)} + {prepnp(do,gen)}
wniosek: : : : {possp} + {prepnp(do,gen)} + {comprepnp(na temat)}
wniosek: : : : {possp} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
wniosek: : : : {possp} + {prepnp(do,gen)} + {prepnp(na,acc); prepnp(o,acc); prepnp(przeciw,dat); prepnp(za,inst); comprepnp(w sprawie); prepncp(o,acc,żeby)}
wniosek: : : : {possp} + {prepnp(z,gen)} + {cp(że)}
wniosek: : : : {possp} + {prepnp(z,gen)} + {or}
wnioskować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wnioskować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wnioskować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wnioskować: _: : imperf: subj{np(str)} + {or}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(żeby2)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wnioskować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(żeby2)}
wnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'obrady',atr)}
wnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'adres',ratr)}
wnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)} + {xp(adl)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)} + {prepnp(w,loc)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {nonch}
wnosić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wnosić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {nonch}
wodować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {refl}
wodować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
wodować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wodować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
wodzić się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
wodzić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
wodzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wodzić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pokuszenie',natr)}
wodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,acc,sg,'nos',natr)}
wodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wojna: : : : {adjp(agr); prepnp(między,inst); prepnp(przeciw,dat); prepnp(z,inst); xp(locat)} + {possp} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
wojować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat); prepnp(z,inst)}
wojować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
wojować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(przeciw,dat); prepnp(z,inst)}
wojować: _: : imperf: subj{np(str)} + {prepnp(pod,inst)} + {prepnp(przeciw,dat); prepnp(z,inst)}
wojować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wojować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
woleć: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
woleć: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{prepnp(niż,str)}
woleć: _: : imperf: subj{np(str)} + {cp(gdy)}
woleć: _: : imperf: subj{np(str)} + {cp(jak)}
woleć: _: : imperf: subj{np(str)} + {cp(jeśli)}
woleć: _: : imperf: subj{np(str)} + {cp(kiedy)}
woleć: _: : imperf: subj{np(str)} + {cp(żeby)}
woleć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
wolno: _: : imperf: controller{np(dat)} + controllee{infp(_)}
wolno: _: : imperf: {cp(żeby)}
wolno: _: : imperf: {np(dat)} + {advp(pron)}
wolno: _: : imperf: {np(dat)} + {np(str)}
wołać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
wołać: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{np(inst)}
wołać: _: : imperf: subj{np(str)} + controller{prepnp(za,inst)} + controllee{np(nom)}
wołać: _: : imperf: subj{np(str)} + {np(gen)}
wołać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
wołać: _: : imperf: subj{np(str)} + obj,controller{prepnp(na,acc)} + controllee{np(nom)}
wołać: _: : imperf: subj{np(str)} + {or}
wołać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wołać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); cp(żeby)}
wołać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wołać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
wołać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
wozić się: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
wozić się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
wozić się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
wpadać: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: _: : imperf: subj{np(str)} + {cp(int)}
wpadać: _: : imperf: subj{np(str)} + {cp(że)}
wpadać: _: : imperf: subj{np(str)} + {cp(żeby)}
wpadać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpadać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wpadać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wpadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wpadać: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
wpadać: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
wpadać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wpajać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wpajać: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(w,acc)}
wpajać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wpajać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(w,acc)}
wpajać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wpajać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(w,acc)}
wpajać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
wpajać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,acc)}
wpaść: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpaść: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpaść: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpaść: _: : perf: subj{np(str)} + {cp(int)}
wpaść: _: : perf: subj{np(str)} + {cp(że)}
wpaść: _: : perf: subj{np(str)} + {cp(żeby)}
wpaść: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpaść: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wpaść: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wpaść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wpaść: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
wpaść: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
wpaść: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wpatrywać się: _: : imperf: subj{np(str)} + {cp(jak)}
wpatrywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,jak)}
wpatrzyć się: _: : perf: subj{np(str)} + {cp(jak)}
wpatrzyć się: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,jak)}
wpędzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(w,acc)}
wpędzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wpędzać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
wpędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wpędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
wpędzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(w,acc)}
wpędzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wpędzić: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
wpędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wpędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
wpisać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wpisać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wpisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wpisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wpisać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wpisywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wpisywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wpisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wplatać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wplątać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wplątać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wplątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wplątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wplątywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wplątywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wpleść się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wpleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
wpłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wpłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wpłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'poczet',atr)}
wpłacić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
wpłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wpłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wpłacić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'poczet',atr)}
wpłynąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wpłynąć: _: : perf: subj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{xp(mod)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wpłynąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wpływać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wpływać: _: : imperf: subj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{xp(mod)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wpływać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wpoić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wpoić: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(w,acc)}
wpoić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wpoić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(w,acc)}
wpoić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wpoić: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(w,acc)}
wpoić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
wpoić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,acc)}
wpraszać się: _: : imperf: subj{np(str)} + {xp(adl)}
wprawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wprawiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wprawiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wprawiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,acc)}
wprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprawić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wprawić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wprawić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wprawić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,acc)}
wprawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprosić się: _: : perf: subj{np(str)} + {xp(adl)}
wprowadzać się: _: : imperf: subj{np(str)} + {xp(adl)}
wprowadzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wprowadzić się: _: : perf: subj{np(str)} + {xp(adl)}
wprowadzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
wpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
wpychać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wpychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wracać się: _: : imperf: subj{np(str)} + {np(dat)}
wracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wracać się: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
wracać się: _: : imperf: subj{np(str)} + {xp(abl)}
wracać się: _: : imperf: subj{np(str)} + {xp(adl)}
wracać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
wracać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); xp(adl)}
wracać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wracać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wracać: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
wracać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wracać: _: : imperf: subj{np(str)} + {xp(abl)}
wracać: _: : imperf: subj{np(str)} + {xp(temp)}
wręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepncp(za,acc,żeby)}
wręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wrócić się: _: : perf: subj{np(str)} + {np(dat)}
wrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wrócić się: _: : perf: subj{np(str)} + {prepnp(po,acc)}
wrócić się: _: : perf: subj{np(str)} + {xp(abl)}
wrócić się: _: : perf: subj{np(str)} + {xp(adl)}
wrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wrócić: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'tarcza',natr); preplexnp(z,inst,sg,'tarcza',natr)}
wrócić: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); xp(adl)}
wrócić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wrócić: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wrócić: _: : perf: subj{np(str)} + {prepnp(po,acc)}
wrócić: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wrócić: _: : perf: subj{np(str)} + {xp(abl)}
wrócić: _: : perf: subj{np(str)} + {xp(adl)}
wrócić: _: : perf: subj{np(str)} + {xp(temp)}
wróżyć: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(na,acc)} + {advp(misc)}
wróżyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {cp(że)}
wróżyć: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(z,gen)}
wróżyć: _: : imperf: subj{np(str)} + {or}
wróżyć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'dwoje',natr)}
wróżyć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,_,'ucho',natr)}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,sg,'twarz',natr)}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,_,'ucho',natr)}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(do,gen,_,'ucho',natr)}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,sg,'twarz',natr)}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,_,'ucho',natr)}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'ucho',natr)} + {or}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'twarz',natr)} + {or}
wrzasnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,_,'ucho',natr)} + {or}
wrzasnąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
wrzasnąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
wrzasnąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,_,'ucho',natr)}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,sg,'twarz',natr)}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,_,'ucho',natr)}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(do,gen,_,'ucho',natr)}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,sg,'twarz',natr)}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,_,'ucho',natr)}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'ucho',natr)} + {or}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'twarz',natr)} + {or}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,_,'ucho',natr)} + {or}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
wrzeszczeć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
wrzeszczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
wrzucać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wrzucać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(inst,sg,'łopata',natr)} + {preplexnp(do,gen,sg,'głowa',natr)}
wrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,sg,'łopata',natr)} + {preplexnp(do,gen,sg,'głowa',natr)}
wrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'siebie',natr)}
wrzucać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wrzucić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'siebie',natr)}
wsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wsiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wsiadać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wsiadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wsiadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wsiadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {or}
wsiadać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wsiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wsiąkać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wsiąknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wsiąknąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wsiąść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wsiąść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wsiąść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wsiąść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wsiąść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wsiąść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {or}
wsiąść: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wskazać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
wskazać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
wskazać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wskazać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wskazać: _: : perf: subj{np(str)} + obj{np(str); cp(że)} + {np(dat)} + {np(inst)}
wskazywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
wskazywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
wskazywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); cp(że); prepncp(na,acc,int); prepncp(na,acc,że)}
wskazywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wskazywać: _: : imperf: subj{np(str)} + obj{np(str); cp(że)} + {np(dat)} + {np(inst)}
wskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wskórać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(u,gen)} + {nonch}
wskórać: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)} + {prepnp(u,gen)} + {nonch}
wskrzesić się: _: : perf: subj{np(str)}
wskrzesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wskrzesić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wskrzeszać się: _: : imperf: subj{np(str)}
wskrzeszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wskrzeszać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wsławiać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wsławiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
wsławiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wsławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
wsławić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wsławić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
wsławić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wsławić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
wsłuchać się: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int)}
wsłuchiwać się: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int)}
wspiąć się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {xp(adl)}
wspierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wspierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
wspierać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wspierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wspierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wspierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wspierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wspinać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(adl)}
wspomagać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)} + {refl}
wspomagać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {refl}
wspomagać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wspomagać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wspominać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wspominać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
wspominać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wspominać: _: : imperf: subj{np(str)} + obj{cp(jak)}
wspominać: _: : imperf: subj{np(str)} + obj{cp(żeby2)}
wspominać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wspominać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
wspomnieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
wspomnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,jak); prepncp(o,loc,że)}
wspomnieć: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wspomnieć: _: : perf: subj{np(str)} + obj{cp(jak)}
wspomnieć: _: : perf: subj{np(str)} + obj{cp(żeby2)}
wspomnieć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wspomnieć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
wspomóc: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)} + {refl}
wspomóc: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {refl}
wspomóc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wspomóc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
współczuć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
współczuć: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,int); ncp(gen,że)}
współczuć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
współdziałać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
współdziałać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
współfinansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
współfinansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
współgrać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
współistnieć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)} + {xp(locat)}
współistnieć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)} + {xp(temp)}
współorganizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
współpracować: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepnp(w,loc); xp(locat)} + {prepnp(z,inst)}
współpracować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na rzecz)}
współpracować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
współpracować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
współrządzić: _: : imperf: subj{np(str)} + obj{np(inst)}
współrządzić: _: : imperf: subj{np(str)} + {xp(locat)}
współtworzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
współuczestniczyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
współzawodniczyć: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)} + {prepnp(z,inst)}
współżyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
wstawiać się: _: : imperf: subj{np(str)} + {np(inst)}
wstawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,inst)}
wstawiać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
wstawiać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(za,inst)}
wstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wstawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wstawić się: _: : perf: subj{np(str)} + {np(inst)}
wstawić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,inst)}
wstawić się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
wstawić się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(za,inst)}
wstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wstawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wstawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wstąpić: _: : perf: subj{np(str)} + {prepnp(na,acc); prepnp(po,acc)} + {xp(adl)}
wstąpić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wstępować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepnp(po,acc)} + {xp(adl)}
wstępować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wstrząsać się: _: : imperf: subj{np(str)} + {np(inst)}
wstrząsać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wstrząsać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wstrząsać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wstrząsać: _: : imperf: {np(inst)}
wstrząsać: _: : imperf: subj{cp(gdy)} + {np(inst)}
wstrząsać: _: : imperf: subj{cp(int)} + {np(inst)}
wstrząsać: _: : imperf: subj{cp(jak)} + {np(inst)}
wstrząsać: _: : imperf: subj{cp(kiedy)} + {np(inst)}
wstrząsać: _: : imperf: subj{cp(że)} + {np(inst)}
wstrząsać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(inst)}
wstrząsać: _: : imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
wstrząsać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wstrząsać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wstrząsnąć się: _: : perf: subj{np(str)} + {np(inst)}
wstrząsnąć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wstrząsnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wstrząsnąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wstrząsnąć: _: : perf: {np(inst)}
wstrząsnąć: _: : perf: subj{cp(gdy)} + {np(inst)}
wstrząsnąć: _: : perf: subj{cp(int)} + {np(inst)}
wstrząsnąć: _: : perf: subj{cp(jak)} + {np(inst)}
wstrząsnąć: _: : perf: subj{cp(kiedy)} + {np(inst)}
wstrząsnąć: _: : perf: subj{cp(że)} + {np(inst)}
wstrząsnąć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(inst)}
wstrząsnąć: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
wstrząsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wstrząsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wstrzemięźliwy: : : : {prepnp(w,loc)}
wstrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
wstrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wstrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
wstrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wstrzymać się: _: : perf: subj{np(str)} + {cp(żeby)}
wstrzymać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wstrzymać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wstrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wstrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wstrzymywać się: _: : imperf: subj{np(str)} + {cp(żeby)}
wstrzymywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wstrzymywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wstrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wstrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wstyd: _: : imperf: controller{np(dat)} + controllee{infp(_)}
wstyd: _: : imperf: {np(dat)} + {cp(int)}
wstyd: _: : imperf: {np(dat)} + {cp(że)}
wstyd: _: : imperf: {np(dat)} + {cp(żeby)}
wstyd: _: : imperf: {np(dat)} + {np(gen)}
wstyd: _: : imperf: {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wstydzić się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
wstydzić się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(przed,inst)}
wstydzić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wstydzić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wstydzić się: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wsunąć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wsuwać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wsypać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wsypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wsypać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wsypać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {refl}
wsypywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wsypywać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {refl}
wszcząć się: _: : perf: subj{np(str)} + {xp(locat)}
wszcząć: _: : perf: subj{np(str)} + obj{np(str)}
wściec się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
wściec się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wściec się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wściec się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
wściec się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wściec: _: : perf: subj{cp(gdy)} + {np(str)}
wściec: _: : perf: subj{cp(jak)} + {np(str)}
wściec: _: : perf: subj{cp(kiedy)} + {np(str)}
wściec: _: : perf: subj{cp(że)} + {np(str)}
wściec: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
wściekać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
wściekać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wściekać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wściekać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
wściekać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wściekać: _: : imperf: subj{cp(gdy)} + {np(str)}
wściekać: _: : imperf: subj{cp(jak)} + {np(str)}
wściekać: _: : imperf: subj{cp(kiedy)} + {np(str)}
wściekać: _: : imperf: subj{cp(że)} + {np(str)}
wściekać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
wtargnąć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wtórować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wtórować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wtrącać się: _: : imperf: subj{np(str)} + {cp(że)}
wtrącać się: _: : imperf: subj{np(str)} + {or}
wtrącać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(w,acc,int); prepncp(w,acc,że)}
wtrącać: _: : imperf: subj{np(str)} + obj{cp(że)}
wtrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wtrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wtrącać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wtrącić się: _: : perf: subj{np(str)} + {cp(że)}
wtrącić się: _: : perf: subj{np(str)} + {or}
wtrącić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(w,acc,int); prepncp(w,acc,że)}
wtrącić: _: : perf: subj{np(str)} + obj{cp(że)}
wtrącić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wtrącić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wtrącić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wtulać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wtulać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wtulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wtulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wtulić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wtulić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wtulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wtulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wtyczkować: _: : imperf: subj{np(str)} + {np(str)}
wtykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wyartykułować się: _: : perf: subj{np(str)}
wyartykułować: _: : perf: subj{np(str)} + {cp(int)}
wyartykułować: _: : perf: subj{np(str)} + {cp(że)}
wyartykułować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyartykułować: _: : perf: subj{np(str)} + {or}
wyasygnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wyasygnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
wyasygnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyasygnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wyasygnować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wybaczać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wybaczać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wybaczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wybaczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wybaczyć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wybaczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wybałuszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wybałuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybałuszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wybałuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybełkotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wybełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wybełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wybełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wybełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wybetonować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wybębniać: _: : imperf: subj{np(str)} + {cp(że)}
wybębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wybębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
wybębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(abl)}
wybębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
wybębniać: _: : imperf: subj{np(str)} + {or}
wybębnić: _: : perf: subj{np(str)} + {cp(że)}
wybębnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wybębnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
wybębnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(abl)}
wybębnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
wybębnić: _: : perf: subj{np(str)} + {or}
wybić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wybić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wybić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wybić się: _: : perf: subj{np(str)} + {prepnp(ponad,acc)}
wybić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wybić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wybić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wybić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(z,gen,_,'głowa',atr)}
wybić: _: : perf: subj{np(str)} + {np(dat)} + {xp(perl)}
wybić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {preplexnp(z,gen,_,'głowa',atr)}
wybić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wybić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wybić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pień',natr)}
wybić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
wybić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wybić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wybić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {or}
wybiec: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
wybiec: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wybiec: _: : perf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'myśl',natr)}
wybiegać się: _: : perf: subj{np(str)} + {xp(locat)}
wybiegać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wybiegać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
wybiegać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wybiegać: _: : imperf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'myśl',natr)}
wybieleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wybierać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
wybierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wybierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
wybierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wybierać się: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wybierać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
wybierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wybierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wybierać: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
wybijać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wybijać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wybijać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wybijać się: _: : imperf: subj{np(str)} + {prepnp(ponad,acc)}
wybijać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wybijać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wybijać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wybijać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(z,gen,_,'głowa',atr)}
wybijać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
wybijać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {preplexnp(z,gen,_,'głowa',atr)}
wybijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wybijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wybijać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pień',natr)}
wybijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
wybijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wybijać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wybijać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {or}
wybrać się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
wybrać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wybrać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
wybrać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wybrać się: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wybrać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
wybrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wybrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wybrać: _: : perf: subj{np(str)} + {prepnp(między,inst)}
wybraniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)} + {refl}
wybraniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
wybraniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)} + {refl}
wybraniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wybraniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wybraniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wybrnąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen); prepncp(z,gen,że)}
wybrnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen); prepncp(z,gen,że)}
wybrnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wybronić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)} + {refl}
wybronić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
wybronić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)} + {refl}
wybronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wybronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wybronić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wybrukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wybuchać: _: : imperf: subj{np(str)} + {cp(że)}
wybuchać: _: : imperf: subj{np(str)} + {np(inst)} + {or}
wybuchnąć: _: : perf: subj{np(str)} + {cp(że)}
wybuchnąć: _: : perf: subj{np(str)} + {np(inst)} + {or}
wybudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wybudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
wybudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wybulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wybulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wycałować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wycałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wycałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
wycałować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {preplexnp(z,gen,sg,'dubeltówka',natr)}
wycedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {or}
wycedzić: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {cp(że)}
wycelować: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wycelować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wycelować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
wycelować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
wyceniać: _: : imperf: subj{np(str)} + {advp(misc)} + {refl}
wyceniać: _: : imperf: subj{np(str)} + {cp(int)}
wyceniać: _: : imperf: subj{np(str)} + {cp(że)}
wyceniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
wyceniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wyceniać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wycenić: _: : perf: subj{np(str)} + {advp(misc)} + {refl}
wycenić: _: : perf: subj{np(str)} + {cp(int)}
wycenić: _: : perf: subj{np(str)} + {cp(że)}
wycenić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
wycenić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wycenić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wycharczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wycharczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wycharczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wycharczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wychlipać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wychlipać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
wychlipać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
wychlipać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wychlusnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychlusnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychlustać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychlustać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychlustać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wychłostać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
wychłostać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wychłostać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wychłostać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wychłostać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wychodzić: _: : perf: subj{np(str)} + obj{np(str)}
wychodzić: _: : imperf: {prepadjp(na,acc)}
wychodzić: _: : imperf: {prepncp(na,acc,że)}
wychodzić: _: : imperf: {prepnp(na,acc)}
wychodzić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen)}
wychodzić: _: : imperf: subj,controller{np(str); ncp(str,że)} + controllee{prepadjp(na,acc)} + {np(dat)}
wychodzić: _: : imperf: subj{cp(że)} + {advp(misc)}
wychodzić: _: : imperf: subj{cp(że)} + {np(dat)} + {prepadjp(na,acc)}
wychodzić: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
wychodzić: _: : imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wychodzić: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'bok',natr)}
wychodzić: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepadjp(na,acc)}
wychodzić: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(na,acc,sg,'zdrowie',natr)}
wychodzić: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(z,gen)}
wychodzić: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
wychodzić: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,_,'ucho',natr)}
wychodzić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'korzyść',natr)}
wychodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wychodzić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wychodzić: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wychodzić: _: : imperf: subj{np(str)} + {prepnp(poza,acc)}
wychodzić: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wychodzić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
wychować się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wychować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wychować się: _: : perf: subj{np(str)} + {xp(locat)}
wychować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wychować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wychować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wychować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wychowywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
wychowywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wychowywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wychowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
wychowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wychowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wychowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wychowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wychudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wychwalać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
wychwalać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
wychwalać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
wychwalać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(wobec,gen)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {or}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {cp(int)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {or}
wychwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wychwycić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
wychwycić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
wychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wychwycić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
wychwycić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wychwycić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wychwycić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wychwytywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
wychwytywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
wychwytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wychwytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wychwytywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
wychwytywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wychwytywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wychwytywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wychylać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychylać się: _: : imperf: subj{np(str)} + {prepnp(przed,acc)}
wychylać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wychylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wychylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
wychylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wychylać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wychylać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wychylić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychylić się: _: : perf: subj{np(str)} + {prepnp(przed,acc)}
wychylić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wychylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wychylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
wychylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wychylić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wychylić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyciąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(co do,gen,sg,'noga',natr)}
wyciąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'noga',natr)}
wyciągać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wyciągać się: _: : imperf: subj{np(str)} + {xp(adl)}
wyciągać się: _: : imperf: subj{np(str)} + {xp(locat)}
wyciągać: _: : imperf: subj{np(str)} + {cp(że)} + {fixed('na jaw')}
wyciągać: _: : imperf: subj{np(str)} + {cp(że)} + {fixed('na światło dzienne')}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen)}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {fixed('na jaw')}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {fixed('na światło dzienne')}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(abl)}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(abl)}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {preplexnp(za,acc,pl,'ucho',natr)}
wyciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wyciągać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wyciągać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wyciągać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wyciągać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wyciągnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wyciągnąć się: _: : perf: subj{np(str)} + {xp(adl)}
wyciągnąć się: _: : perf: subj{np(str)} + {xp(locat)}
wyciągnąć: _: : perf: subj{np(str)} + {cp(że)} + {fixed('na jaw')}
wyciągnąć: _: : perf: subj{np(str)} + {cp(że)} + {fixed('na światło dzienne')}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen)}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {fixed('na jaw')}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {fixed('na światło dzienne')}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(abl)}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(abl)}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {preplexnp(za,acc,pl,'ucho',natr)}
wyciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wyciągnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wyciągnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wyciągnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wyciągnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wyciec: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyciekać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wycierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wycierać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wycierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wycierać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wycierać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
wycierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wycierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
wycierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wycierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wycierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepnp(w,acc)} + {prepnp(z,gen)}
wycierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wycierać: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {refl}
wycierać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wycinać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(abl)}
wycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(co do,gen,sg,'noga',natr)}
wycinać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'noga',natr)}
wyciskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(z,gen)}
wyciskać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wyciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyciskać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wyciskać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wyciskać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wyciskać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wycisnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)} + {prepnp(z,gen)}
wycisnąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wycisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wycisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wycisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wycisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wycisnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wycisnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wycisnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wycisnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wyciszać się: _: : imperf: subj{np(str)}
wyciszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyciszyć się: _: : perf: subj{np(str)}
wyciszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wycofać się: _: : perf: subj{np(str)} + {prepncp(z,gen,że)}
wycofać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wycofać się: _: : perf: subj{np(str)} + {xp(abl)}
wycofać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycofać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wycofywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wycofywać się: _: : imperf: subj{np(str)} + {xp(abl)}
wycofywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycofywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyczarterować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wyczarterować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wyczarterować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wyczarterować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
wyczarterować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wyczerpać się: _: : perf: subj{np(str)} + {np(dat)}
wyczerpać się: _: : perf: subj{np(str)} + {np(inst)}
wyczerpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyczerpywać się: _: : imperf: subj{np(str)} + {np(dat)}
wyczerpywać się: _: : imperf: subj{np(str)} + {np(inst)}
wyczerpywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyczuć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',natr)}
wyczuć: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
wyczuć: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
wyczuć: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(przez,acc,sg,'skóra',natr)}
wyczuć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyczuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyczuwać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',natr)}
wyczuwać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
wyczuwać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
wyczuwać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(przez,acc,sg,'skóra',natr)}
wyczuwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyczuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyczyniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(z,gen)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(z,gen)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(żeby)} + {xp(locat)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(że)} + {comprepnp(na temat)} + {xp(locat)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(o,loc)} + {xp(locat)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(z,gen)}
wyczytać: _: : perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
wyczytać: _: : perf: subj{np(str)} + obj{nonch} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
wyczytać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int)}
wyczytać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
wyczytać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
wyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {or}
wyć: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
wyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
wyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
wyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {or}
wyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)} + {or}
wyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {or}
wyć: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wyć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wyć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,żeby)}
wyć: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
wyć: _: : imperf: subj{or} + {np(dat)} + {xp(locat)}
wyćwiczyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wyćwiczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
wyćwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyćwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wyćwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
wydać się: _: : perf: subj,controller{E} + controllee{infp(imperf)} + {np(dat)}
wydać się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
wydać się: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
wydać się: _: : perf: subj{cp(int)}
wydać się: _: : perf: subj{cp(jakby)} + {np(dat)}
wydać się: _: : perf: subj{cp(że)} + {np(dat)}
wydać się: _: : perf: subj{np(str)}
wydać się: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wydać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wydać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wydać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
wydać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydarzyć się: _: : perf: subj{cp(że)}
wydarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
wydarzyć się: _: : perf: subj{np(str)} + {xp(locat)}
wydatkować się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wydatkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wydawać się: _: : imperf: subj,controller{cp(int)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{cp(int)} + controllee{np(inst)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{cp(żeby)} + controllee{np(inst)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{cp(że)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{cp(że)} + controllee{np(inst)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{E} + controllee{infp(imperf)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: _: : imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)} + {np(dat)}
wydawać się: _: : imperf: subj{cp(jakby)} + {np(dat)}
wydawać się: _: : imperf: subj{cp(że)} + {np(dat)}
wydawać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wydawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wydawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wydawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
wydawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
wydąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wydąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wydębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydębić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wydłubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wydłubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wydłubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydłubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wydłubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wydłubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydłużać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydłużać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydłużyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydłużyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydobrzeć: _: : perf: subj{np(str)} + {advp(misc)}
wydobrzeć: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)}
wydobrzeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wydobyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wydobyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wydobyć się: _: : perf: subj{np(str)} + {xp(abl)}
wydobyć: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wydobyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydobyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydobyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydobyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wydobywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wydobywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wydobywać się: _: : imperf: subj{np(str)} + {xp(abl)}
wydobywać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wydobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wydoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wydoić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydoić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydoić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wydoić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wydoić: _: : perf: subj{np(str)} + {refl}
wydostać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wydostać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydostać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydostać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydostać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydrapać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wydrapywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydrapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydrapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wydrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wydrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydrążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wydrukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wydrukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wydrukować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wydumać: _: : perf: subj{np(str)} + {cp(int)}
wydumać: _: : perf: subj{np(str)} + {cp(że)}
wydumać: _: : perf: subj{np(str)} + {cp(żeby)}
wydumać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wydumać: _: : perf: subj{np(str)} + {or}
wydychać się: _: : perf: subj{np(str)}
wydychać: _: : perf: subj{np(str)}
wydychać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydymać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
wydymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wydymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wydymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wydymać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wydymać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydziedziczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydziedziczać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wydziedziczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydziedziczyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wydzielać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
wydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
wydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)} + {prepnp(z,gen)}
wydzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wydzielić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
wydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
wydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)} + {prepnp(z,gen)}
wydzielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wydzierżawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wydzierżawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wydziwiać: _: : imperf: subj{np(str)} + {cp(int)}
wydziwiać: _: : imperf: subj{np(str)} + {or}
wydziwiać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wydziwiać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wydziwiać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
wydziwiać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
wydziwiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wydźwigać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wydźwigać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wydźwigać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wydźwigać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wydźwigiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wydźwigiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wydźwigiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wydźwigiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wydźwignąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wydźwignąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wydźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wydźwignąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyedukować się: _: : perf: subj{np(str)} + {advp(misc)}
wyedukować się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
wyedukować się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
wyedukować się: _: : perf: subj{np(str)} + {cp(int)}
wyedukować się: _: : perf: subj{np(str)} + {cp(że)}
wyedukować się: _: : perf: subj{np(str)} + {cp(żeby)}
wyedukować się: _: : perf: subj{np(str)} + {np(inst)}
wyedukować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wyedukować się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wyedukować się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wyedukować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyedukować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyedukować się: _: : perf: subj{np(str)} + {xp(locat)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyedukować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyegzekwować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyeksmitować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wyeksploatować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyeksploatować: _: : perf: subj{np(str)} + {refl}
wyeksponować się: _: : perf: subj{np(str)}
wyeksponować: _: : perf: subj{np(str)} + {cp(że)}
wyeksponować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyeksportować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyekwipować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyekwipować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wyeliminować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyemigrować: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wyemitować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wygadać się: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
wygadać się: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
wygadać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wygadać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wygadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
wygadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,jak); prepncp(z,inst,że)}
wygadać się: _: : perf: subj{np(str)} + {or}
wygadać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(przed,inst)}
wygadać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
wygadać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wygadać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wygadać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,jak); prepncp(z,inst,że)}
wygadać się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,jak); prepncp(z,inst,że)} + {xp(locat)}
wygadać: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
wygadać: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
wygadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wygadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wygadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
wygadać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wygadać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {prepnp(przed,inst)}
wygadać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {xp(locat)}
wygadać: _: : perf: subj{np(str)} + {or}
wygadać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(przed,inst)}
wygadać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
wygadać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wygadać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wygadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wygadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wygadywać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
wygadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
wygadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,że)}
wygadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wygadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wygadywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
wygadywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wyganiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
wyganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygasać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
wygasać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wygasić się: _: : perf: subj{np(str)} + {np(dat)}
wygasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygasnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
wygasnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wygaszać się: _: : imperf: subj{np(str)} + {np(dat)}
wygaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygenerować się: _: : perf: subj{cp(że)} + {np(dat)}
wygenerować się: _: : perf: subj{np(str)} + {np(dat)}
wygenerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wygenerować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygenerować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wygenerować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wygiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
wygiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wygiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wygiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wygiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wygiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wygiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wygiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wygiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
wyginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wyginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wyginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wyginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wyginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wyginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wyginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyginąć: _: : perf: subj{np(str)} + {comprepnp(z powodu)} + {xp(temp)}
wyglądać: _: : imperf: {cp(że)}
wyglądać: _: : imperf: {prepncp(na,acc,że)}
wyglądać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {np(dat)}
wyglądać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(dat)}
wyglądać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
wyglądać: _: : imperf: subj{np(str)} + {np(gen)}
wyglądać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wyglądać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
wygładzać się: _: : imperf: subj{np(str)} + {np(dat)}
wygładzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wygładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wygładzić się: _: : perf: subj{np(str)} + {np(dat)}
wygładzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wygłaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygłaszać: _: : imperf: subj{np(str)} + {or}
wygłodzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wygłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wygłosić: _: : perf: subj{np(str)} + {cp(że)}
wygłosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygłosić: _: : perf: subj{np(str)} + {or}
wygłupiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wygłupiać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wygłupiać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst); prepncp(z,inst,że)}
wygłupić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wygłupić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wygłupić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst); prepncp(z,inst,że)}
wygnać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
wygnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygolić: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
wygolić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
wygolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
wygolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wygolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wygonić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
wygonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygospodarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygospodarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wygrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
wygrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wygrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wygrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wygrać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wygrażać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wygrażać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wygrażać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wygrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
wygrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wygrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wygrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wygrywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wygryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wygryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wygryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wygryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wygryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wygryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wygrzebać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wygrzebać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wygrzebać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wygrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wygrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wygrzebywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wygrzebywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wygrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wygrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyguzdrać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyguzdrać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygwizdać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygwizdać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wygwizdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygwizdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyhaftować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wyhaftować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wyhamować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(dur)}
wyhamować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyhamować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(dur)}
wyhamować: _: : perf: subj{np(str)} + {xp(locat)}
wyhamowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(dur)}
wyhamowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyhamowywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(dur)}
wyhamowywać: _: : imperf: subj{np(str)} + {xp(locat)}
wyhasać się: _: : perf: subj{np(str)} + {xp(locat)}
wyhodować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyhodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyhodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyhodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyhodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyhulać się: _: : perf: subj{np(str)} + {xp(locat)}
wyidealizować: _: : perf: subj{np(str)} + obj{np(str)}
wyizolować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyizolować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyizolować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyizolować: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wyizolować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wyjadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyjaławiać się: _: : imperf: subj{np(str)} + {np(dat)}
wyjaławiać się: _: : imperf: subj{np(str)} + {np(inst)}
wyjaławiać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyjaławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyjaławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyjaławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyjałowić się: _: : perf: subj{np(str)} + {np(dat)}
wyjałowić się: _: : perf: subj{np(str)} + {np(inst)}
wyjałowić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyjałowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyjałowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyjałowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyjałowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wyjałowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyjaśniać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśniać się: _: : imperf: subj{cp(int)}
wyjaśniać się: _: : imperf: subj{cp(że)}
wyjaśniać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)}
wyjaśniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
wyjaśniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśniać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)} + {or}
wyjaśnić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
wyjaśnić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśnić się: _: : perf: subj{cp(int)}
wyjaśnić się: _: : perf: subj{cp(że)}
wyjaśnić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)}
wyjaśnić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
wyjaśnić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśnić: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)} + {or}
wyjawiać się: _: : imperf: subj{cp(że)}
wyjawiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wyjawiać się: _: : imperf: subj{np(str)} + {xp(abl)}
wyjawiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wyjawiać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wyjawiać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wyjawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyjawić się: _: : perf: subj{cp(że)}
wyjawić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyjawić się: _: : perf: subj{np(str)} + {xp(abl)}
wyjawić: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyjawić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wyjawić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wyjawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(spod,gen,sg,'prawo',atr)}
wyjąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyjąkać: _: : perf: subj{np(str)} + {cp(int)}
wyjąkać: _: : perf: subj{np(str)} + {cp(że)}
wyjąkać: _: : perf: subj{np(str)} + {cp(żeby)}
wyjąkać: _: : perf: subj{np(str)} + obj{np(str)}
wyjąkać: _: : perf: subj{np(str)} + {or}
wyjechać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wyjechać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wyjechać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wyjechać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyjechać: _: : perf: subj{np(str)} + {xp(abl)}
wyjechać: _: : perf: subj{np(str)} + {xp(adl)}
wyjeść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyjeżdżać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wyjeżdżać: _: : imperf: subj{np(str)} + {xp(abl)}
wyjeżdżać: _: : imperf: subj{np(str)} + {xp(adl)}
wyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(spod,gen,sg,'prawo',atr)}
wyjmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyjść: _: : perf: {prepadjp(na,acc)}
wyjść: _: : perf: {prepncp(na,acc,że)}
wyjść: _: : perf: {prepnp(na,acc)}
wyjść: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen)}
wyjść: _: : perf: subj,controller{np(str); ncp(str,że)} + controllee{prepadjp(na,acc)} + {np(dat)}
wyjść: _: : perf: subj{cp(że)} + {advp(misc)}
wyjść: _: : perf: subj{cp(że)} + {np(dat)} + {prepadjp(na,acc)}
wyjść: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
wyjść: _: : perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyjść: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'bok',natr)}
wyjść: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepadjp(na,acc)}
wyjść: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(z,gen)}
wyjść: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
wyjść: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,_,'ucho',natr)}
wyjść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'korzyść',natr)}
wyjść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'spotkanie',natr)}
wyjść: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'zdrowie',natr)}
wyjść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wyjść: _: : perf: subj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
wyjść: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyjść: _: : perf: subj{np(str)} + {prepnp(poza,acc)}
wyjść: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wyjść: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wykańczać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wykańczać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
wykańczać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
wykańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wykarczować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykarczować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
wykarmiać się: _: : imperf: subj{np(str)} + {np(inst)}
wykarmiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykarmiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykarmiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wykarmić się: _: : perf: subj{np(str)} + {np(inst)}
wykarmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykarmić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykarmić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wykazać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wykazać: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
wykazywać się: _: : imperf: subj{np(str)} + {np(inst)} + {or}
wykazywać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
wykazywać: _: : imperf: subj{np(str)} + {or}
wykąpać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykąpać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
wykierować się: _: : perf: subj{np(str)} + {advp(misc)}
wykierować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wykierować się: _: : perf: subj{np(str)} + {xp(adl)}
wykierować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
wykierować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykierować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wykląć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
wykląć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wykląć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wykląć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyklepać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyklepać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyklepać: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyklepać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wyklepać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
wyklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wyklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wyklepywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
wyklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wyklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wyklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
wyklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
wyklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
wyklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wykluczać: _: : imperf: subj{np(str)} + {cp(że)}
wykluczać: _: : imperf: subj{np(str)} + {cp(żeby)}
wykluczać: _: : imperf: subj{np(str)} + {np(str); ncp(str,że)}
wykluczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykluczyć: _: : perf: subj{np(str)} + obj{cp(że)}
wykluczyć: _: : perf: subj{np(str)} + obj{cp(żeby)}
wykluczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
wykluczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykluć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wykluwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wykładać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc); prepncp(na,loc,że)}
wykładać się: _: : imperf: subj{np(str)} + {xp(locat)}
wykładać: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wykładać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wykładać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wykładać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
wykładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wykładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wykłuć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
wykłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wykombinować: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
wykombinować: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
wykombinować: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wykombinować: _: : perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
wykombinować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wykombinować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wykombinować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykombinować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {nonch}
wykonać się: _: : perf: subj{np(str)}
wykonać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
wykonać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykonać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykonać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykonywać się: _: : imperf: subj{np(str)}
wykonywać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
wykonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykończyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wykończyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
wykończyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
wykończyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wykopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wykopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wykopać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykopać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wykopać: _: : perf: subj{np(str)} + {xp(abl)} + {refl}
wykorzystać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wykorzystać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wykorzystać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {cp(żeby)}
wykorzystać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wykorzystać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
wykorzystać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykorzystywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wykorzystywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wykorzystywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {cp(żeby)}
wykorzystywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wykorzystywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
wykorzystywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykosztować się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykosztowywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykpić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wykpić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wykpić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wykpiwać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wykpiwać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wykpiwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wykraczać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(poza,acc); prepncp(poza,acc,int); prepncp(poza,acc,że)}
wykraczać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że)}
wykraczać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(poza,acc); prepncp(poza,acc,int); prepncp(poza,acc,że)}
wykradać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wykradać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wykraść się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wykraść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wykrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wykrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wykrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wykrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wykrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wykreować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {refl}
wykreować: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {refl}
wykreować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
wykreować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
wykreować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykreślać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykreślać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykreślić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykreślić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wykręcać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
wykręcać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wykręcać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
wykręcać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wykręcać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wykręcać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
wykręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)} + {xp(adl)}
wykręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wykręcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wykręcić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
wykręcić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wykręcić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
wykręcić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wykręcić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wykręcić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
wykręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)} + {xp(adl)}
wykręcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wykrochmalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
wykroić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wykroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wykroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wykroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wykroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wykroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wykrwawiać się: _: : imperf: subj{np(str)}
wykrwawiać: _: : imperf: subj{np(str)} + obj{np(str)}
wykrwawić się: _: : perf: subj{np(str)}
wykrwawić: _: : perf: subj{np(str)} + obj{np(str)}
wykryć się: _: : perf: subj{cp(że)}
wykryć się: _: : perf: subj{np(str)}
wykryć: _: : perf: subj{np(str)} + {cp(int)}
wykryć: _: : perf: subj{np(str)} + obj{cp(że)}
wykryć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wykryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wykryć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wykrywać się: _: : imperf: subj{np(str)}
wykrywać: _: : imperf: subj{np(str)} + {cp(int)}
wykrywać: _: : imperf: subj{np(str)} + obj{cp(że)}
wykrywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wykrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wykrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wykrzesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wykrzesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wykrzyczeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wykrzyczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wykrzyczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wykrzyczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wykrzyczeć: _: : perf: subj{np(str)} + {np(dat)} + {or}
wykrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wykrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wykrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
wykrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(ku,dat)} + {cp(int)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(ku,dat)} + {cp(że)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(ku,dat)} + {cp(żeby)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(ku,dat)} + {or}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wykrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
wykrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wykrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wykrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wykrzykiwać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wykrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wykrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wykrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
wykrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)} + {cp(int)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)} + {cp(że)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)} + {cp(żeby)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)} + {or}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wykrzykiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
wykrzyknąć: _: : perf: subj{np(str)} + obj{np(str)}
wykrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wykrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wykrzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
wykrzywiać się: _: : imperf: subj{np(str)} + {cp(że)}
wykrzywiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wykrzywiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wykrzywiać się: _: : imperf: subj{np(str)} + {or}
wykrzywiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wykrzywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykrzywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wykrzywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykrzywić się: _: : perf: subj{np(str)} + {cp(że)}
wykrzywić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wykrzywić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wykrzywić się: _: : perf: subj{np(str)} + {or}
wykrzywić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wykrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wykrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykupić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wykupić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wykupić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
wykupić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)} + {refl}
wykupić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)} + {refl}
wykupywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wykupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wykupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
wykupywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)} + {refl}
wykupywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)} + {refl}
wykurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wykurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wykwalifikować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wykwalifikować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wykwalifikować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wykwalifikować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wykwalifikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wykwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wykwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykwaterować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wykwaterowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wylać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wylać: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'dziecko',natr)} + {preplexnp(z,inst,sg,'kąpiel',natr)}
wylać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wylać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
wylać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wylansować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
wylansować: _: : perf: subj{np(str)} + {cp(że)}
wylansować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
wylansować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wylansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wylansować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wylansować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wylansować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wylansować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
wylatywać: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylatywać: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylatywać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylatywać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylatywać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylatywać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylatywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylatywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylatywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wylatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wylatywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wylatywać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wylądować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
wylądować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
wylecieć: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylecieć: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylecieć: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylecieć: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylecieć: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylecieć: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylecieć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'głowa',natr)}
wylecieć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(z,gen,sg,'pamięć',natr)}
wylecieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wylecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wylecieć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wylecieć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wyleczyć się: _: : perf: subj{np(str)} + {np(dat)}
wyleczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyleczyć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen)}
wyleczyć się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyleczyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wyleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wylegiwać się: _: : imperf: subj{np(str)} + {xp(locat)}
wylegiwać: _: : imperf: subj{np(str)} + obj{np(str)}
wylewać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wylewać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'dziecko',natr)} + {preplexnp(z,inst,sg,'kąpiel',natr)}
wylewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wylewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
wylewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wylewać: _: : imperf: subj{np(str)} + {preplexnp(za,acc,sg,'kołnierz',natr)}
wyleźć: _: : perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyleźć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyleźć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
wyleźć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wylicytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyliczać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
wyliczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyliczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyliczyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
wyliczyć: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wyliczyć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wyliczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wyliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wylizać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wylizać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wylizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wylizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wylizywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wylizywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wylizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wylizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wylosować: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
wylosować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wylosować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spośród,gen)}
wylosować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyludniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyludniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyludnić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyludnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyluzować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyluzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyluzować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyładować się: _: : perf: subj{np(str)} + {np(dat)}
wyładować się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wyładować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyładować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
wyładować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyładować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyładować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyładowywać się: _: : imperf: subj{np(str)} + {np(dat)}
wyładowywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wyładowywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wyładowywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
wyładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyłamać się: _: : perf: subj{np(str)} + {np(dat)}
wyłamać się: _: : perf: subj{np(str)} + {or}
wyłamać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyłamać się: _: : perf: subj{np(str)} + {prepnp(spod,gen)}
wyłamać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyłamywać się: _: : imperf: subj{np(str)} + {np(dat)}
wyłamywać się: _: : imperf: subj{np(str)} + {or}
wyłamywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wyłamywać się: _: : imperf: subj{np(str)} + {prepnp(spod,gen)}
wyłamywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyłaniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyłaniać się: _: : imperf: subj{np(str)} + {xp(abl)}
wyłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłapać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
wyłapać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
wyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyłapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyłapać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
wyłapać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wyłapać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wyłapać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wyłapywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
wyłapywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
wyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyłapywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
wyłapywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wyłapywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wyłapywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wyławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wyławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyłazić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
wyłazić: _: : imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyłazić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyłazić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
wyłazić: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyłączać się: _: : imperf: subj{np(str)} + {np(dat)}
wyłączać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wyłączać się: _: : imperf: subj{np(str)} + {prepnp(spod,gen)}
wyłączać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(poza,acc)}
wyłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spod,gen)}
wyłączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłączyć się: _: : perf: subj{np(str)} + {np(dat)}
wyłączyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyłączyć się: _: : perf: subj{np(str)} + {prepnp(spod,gen)}
wyłączyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(poza,acc)}
wyłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spod,gen)}
wyłączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłgać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wyłgać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wyłgać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wyłgać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wyłgać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wyłgiwać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wyłgiwać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wyłgiwać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wyłgiwać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wyłgiwać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wyłonić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyłonić się: _: : perf: subj{np(str)} + {xp(abl)}
wyłonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyłonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyłowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wyłowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyłowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyłożyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc); prepncp(na,loc,że)}
wyłożyć się: _: : perf: subj{np(str)} + {xp(locat)}
wyłożyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wyłożyć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
wyłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wyłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wyłudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyłudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyłuskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyłuskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wymachiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
wymachiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
wymachiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wymachiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wymachiwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wymagać: _: : imperf: subj{cp(int)} + {np(gen)}
wymagać: _: : imperf: subj{cp(że)} + {np(gen)}
wymagać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(gen)}
wymagać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(od,gen)}
wymagać: _: : imperf: subj{np(str)} + obj{np(gen); cp(żeby); ncp(gen,że); ncp(gen,żeby)} + {prepnp(od,gen)}
wymarzyć się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
wymarzyć się: _: : perf: subj{cp(żeby)} + {np(dat)}
wymarzyć się: _: : perf: subj{cp(że)} + {np(dat)}
wymarzyć się: _: : perf: subj{np(str)} + {np(dat)}
wymarzyć: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
wymarzyć: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
wymarzyć: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wymarzyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {lexnp(dat,_,'siebie',natr)}
wymawiać się: _: : imperf: subj{np(str)} + {cp(że)}
wymawiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wymawiać się: _: : imperf: subj{np(str)} + {or}
wymawiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wymawiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wymawiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wymawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wymazać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wymazać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wymazać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wymazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wymazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wymazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wymazywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wymazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wymazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wymeldować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wymeldować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wymeldować: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wymeldować: _: : perf: subj{np(str)} + {xp(abl)} + {refl}
wymęczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
wymęczyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
wymęczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(u,gen)}
wymęczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wymiarować: _: : _: subj{np(str)} + obj{np(str)}
wymieniać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wymieniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
wymieniać: _: : imperf: subj{np(str)} + {cp(int)}
wymieniać: _: : imperf: subj{np(str)} + {cp(że)}
wymieniać: _: : imperf: subj{np(str)} + {np(str); ncp(str,że)} + {prepnp(w,loc)} + {or}
wymieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
wymieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(dat)}
wymieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'imię',natr); preplexnp(z,gen,sg,'nazwisko',natr)}
wymieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wymienić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wymienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
wymienić: _: : perf: subj{np(str)} + {cp(int)}
wymienić: _: : perf: subj{np(str)} + {cp(że)}
wymienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {np(dat)}
wymienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(dat)}
wymienić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)} + {or}
wymienić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'imię',atr); preplexnp(z,gen,sg,'nazwisko',atr)}
wymienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wymierać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
wymierać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
wymierzyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
wymierzyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
wymierzyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wymierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wymierzyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wymieszać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wymieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wyminąć się: _: : perf: subj{np(str)} + {xp(locat)}
wyminąć: _: : perf: subj{np(str)} + obj{np(str)}
wyminąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wymiotować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wymiotować: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wymiotować: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
wymiotować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wymknąć się: _: : perf: subj{cp(że)} + {np(dat)}
wymknąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(spod,gen)}
wymknąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wymknąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wymknąć się: _: : perf: subj{or} + {np(dat)}
wymordować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wymordować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymóc: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {prepnp(na,loc)}
wymóc: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {prepnp(od,gen)}
wymóc: _: : perf: subj{np(str)} + obj{cp(że)} + {np(inst)} + {prepnp(na,loc)}
wymóc: _: : perf: subj{np(str)} + obj{cp(że)} + {np(inst)} + {prepnp(od,gen)}
wymóc: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst)} + {prepnp(na,loc)}
wymóc: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst)} + {prepnp(od,gen)}
wymówić się: _: : perf: subj{np(str)} + {cp(że)}
wymówić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wymówić się: _: : perf: subj{np(str)} + {or}
wymówić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wymówić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wymówić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wymówić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wymrzeć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
wymrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
wymurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wymusić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(na,loc)}
wymusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
wymusić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {prepnp(na,loc)}
wymusić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst); ncp(inst,że)} + {prepnp(na,loc)}
wymusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wymusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wymusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
wymusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wymuszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(na,loc)}
wymuszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
wymuszać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {prepnp(na,loc)}
wymuszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst); ncp(inst,że)} + {prepnp(na,loc)}
wymuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wymuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wymuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
wymuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wymusztrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wymyć się: _: : perf: subj{np(str)} + {xp(abl)}
wymyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wymyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wymyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wymyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wymyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wymyć: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
wymykać się: _: : imperf: subj{cp(że)} + {np(dat)}
wymykać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(spod,gen)}
wymykać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wymykać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wymykać się: _: : imperf: subj{or} + {np(dat)}
wymyślać: _: : imperf: subj{np(str)} + {cp(int)}
wymyślać: _: : imperf: subj{np(str)} + {cp(że)}
wymyślać: _: : imperf: subj{np(str)} + {cp(żeby)}
wymyślać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wymyślać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wymyślać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
wymyślać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wymyśleć: _: : perf: subj{np(str)} + {cp(int)}
wymyśleć: _: : perf: subj{np(str)} + {cp(że)}
wymyśleć: _: : perf: subj{np(str)} + {cp(żeby)}
wymyśleć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
wymyślić: _: : perf: subj{np(str)} + {cp(int)}
wymyślić: _: : perf: subj{np(str)} + {cp(że)}
wymyślić: _: : perf: subj{np(str)} + {cp(żeby)}
wymyślić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
wymyślić: _: : perf: subj{np(str)} + {or}
wynagradzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
wynagradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wynagrodzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
wynagrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wynająć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wynająć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wynająć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wynająć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wynająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wynająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wynajmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wynajmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wynajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wynajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wynajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wynajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wynaradawiać się: _: : imperf: subj{np(str)}
wynaradawiać: _: : imperf: subj{np(str)} + obj{np(str)}
wynarodowić się: _: : perf: subj{np(str)}
wynarodowić: _: : perf: subj{np(str)} + obj{np(str)}
wynegocjować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynegocjować: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: _: : perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynegocjować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynegocjować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynieść się: _: : perf: subj{np(str)} + {prepnp(nad,acc)}
wynieść się: _: : perf: subj{np(str)} + {prepnp(ponad,acc)}
wynieść się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynieść: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
wynieść: _: : perf: subj{np(str)} + {np(str)}
wynieść: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'niebiosa',natr)}
wynieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wynieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wynieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
wynieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
wynieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wynieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynikać: _: : imperf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wyniknąć: _: : perf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wynosić się: _: : imperf: subj{np(str)} + {prepnp(nad,acc)}
wynosić się: _: : imperf: subj{np(str)} + {prepnp(ponad,acc)}
wynosić się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynosić: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
wynosić: _: : imperf: subj{np(str)} + {np(str)}
wynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'niebiosa',natr)}
wynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
wynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
wynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wynosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wyobrazić: _: : perf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrazić: _: : perf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrazić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: _: : imperf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: _: : imperf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
wyodrębniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(spośród,gen)}
wyodrębniać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wyodrębniać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wyodrębniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyodrębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyodrębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyodrębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyodrębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyodrębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyodrębnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(spośród,gen)}
wyodrębnić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyodrębnić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wyodrębnić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyodrębnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyodrębnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyodrębnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyodrębnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyodrębnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyolbrzymić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wypaczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wypaczać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wypaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypadać: _: : imperf: {np(dat)} + {advp(pron)}
wypadać: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)}
wypadać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {advp(misc)}
wypadać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {prepnp(z,gen)}
wypadać: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
wypadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypadać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wypadać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {advp(misc)}
wypadać: _: : imperf: subj{np(str)} + {xp(temp)}
wypalać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wypalać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wypalać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wypalać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wypalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypalać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
wypalać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wypalić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wypalić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wypalić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wypalić: _: : perf: subj{np(str)} + {np(dat)} + {or}
wypalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypalić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
wypalić: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wypastować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypaść: _: : perf: controller{np(dat)} + controllee{infp(_)}
wypaść: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {advp(misc)}
wypaść: _: : perf: subj{cp(żeby)} + {np(dat)} + {prepnp(z,gen)}
wypaść: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
wypaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypaść: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypaść: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wypaść: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {advp(misc)}
wypaść: _: : perf: subj{np(str)} + {xp(temp)}
wypatroszyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wypatroszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wypatrywać: _: : imperf: subj{np(str)} + {cp(int)} + {xp(abl)}
wypatrywać: _: : imperf: subj{np(str)} + {cp(że)} + {xp(abl)}
wypatrywać: _: : imperf: subj{np(str)} + obj{np(gen)} + {xp(abl)} + {xp(locat)}
wypatrywać: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(str,pl,'oko',natr)}
wypatrzyć: _: : perf: subj{np(str)} + {cp(int)} + {xp(abl)}
wypatrzyć: _: : perf: subj{np(str)} + {cp(że)} + {xp(abl)}
wypatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(locat)}
wypatrzyć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(str,pl,'oko',natr)}
wypchać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypchać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wypchać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wypchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypchnąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypchnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wypchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypełniać się: _: : imperf: subj{np(str)} + {np(inst)}
wypełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypełnić się: _: : perf: subj{np(str)} + {np(inst)}
wypełnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypełzać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wypełzać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypełznąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wypełznąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wypić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wypić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wypierać się: _: : imperf: subj{np(str)} + {cp(jakoby)}
wypierać się: _: : imperf: subj{np(str)} + {cp(że)}
wypierać się: _: : imperf: subj{np(str)} + {cp(żeby)}
wypierać się: _: : imperf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
wypierać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {or}
wypierać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)} + {xp(abl)}
wypierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wypijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wypijać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wypisać się: _: : perf: subj{np(str)} + {np(dat)}
wypisać: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypisać: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
wypisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wypisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypisać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wypisać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wypisać: _: : perf: subj{np(str)} + {xp(abl)} + {refl}
wypisywać się: _: : imperf: subj{np(str)} + {np(dat)}
wypisywać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypisywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypisywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(o,loc)} + {xp(locat)}
wypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
wypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)} + {xp(locat)}
wypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wypisywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wypisywać: _: : imperf: subj{np(str)} + {xp(abl)} + {refl}
wyplątać się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyplątać się: _: : perf: subj{np(str)} + {xp(abl)}
wyplątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyplątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyplątywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyplątywać się: _: : imperf: subj{np(str)} + {xp(abl)}
wyplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wypluć: _: : perf: subj{np(str)} + {cp(int)} + {preplexnp(z,gen,_,'siebie',natr)}
wypluć: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,_,'siebie',natr)}
wypluć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypluć: _: : perf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wypluwać: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(z,gen,_,'siebie',natr)}
wypluwać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,_,'siebie',natr)}
wypluwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypluwać: _: : imperf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wypłacać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)}
wypłacać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wypłacić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)}
wypłacić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wypłakać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wypłakać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wypłakać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wypłakać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wypłakać się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {lexnp(str,pl,'łza',atr)}
wypłakać się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {lexnp(str,pl,'oko',atr)}
wypłakać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wypłakać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wypłakać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wypłakać: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
wypłakać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
wypłakiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wypłakiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wypłakiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wypłakiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wypłakiwać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {lexnp(str,pl,'łza',atr)}
wypłakiwać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {lexnp(str,pl,'oko',atr)}
wypłakiwać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wypłakiwać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wypłakiwać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wypłakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
wypłakiwać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
wypłynąć: _: : perf: subj{cp(że)} + {prepnp(z,gen)}
wypłynąć: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
wypłynąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypłynąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypłynąć: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'fala',natr)}
wypłynąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wypływać się: _: : perf: subj{np(str)}
wypływać: _: : imperf: subj{cp(że)} + {prepnp(z,gen)}
wypływać: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
wypływać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypływać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypływać: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'fala',natr)}
wypływać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wypocząć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wypocząć: _: : perf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
wypoczywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wypoczywać: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
wypoczywać: _: : imperf: subj{np(str)} + {xp(locat)}
wypogadzać się: _: : imperf: subj{E} + {xp(locat)}
wypogadzać się: _: : imperf: subj{np(str)} + {np(dat)}
wypogadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypolerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypominać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wypominać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wypominać: _: : imperf: subj{np(str)} + obj{cp(jak)} + {np(dat)}
wypominać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wypominać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wypominać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wypomnieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
wypomnieć: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wypomnieć: _: : perf: subj{np(str)} + obj{cp(jak)} + {np(dat)}
wypomnieć: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wypomnieć: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wypomnieć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wyposażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wyposażać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wyposażyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wyposażyć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wypowiadać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wypowiadać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wypowiadać się: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
wypowiadać się: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
wypowiadać się: _: : imperf: subj{np(str)} + {cp(int)}
wypowiadać się: _: : imperf: subj{np(str)} + {or}
wypowiadać się: _: : imperf: subj{np(str)} + {prepnp(co do,gen)}
wypowiadać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wypowiadać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,że); prepncp(za,inst,żeby)}
wypowiadać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
wypowiadać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wypowiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypowiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
wypowiedzieć się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wypowiedzieć się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
wypowiedzieć się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
wypowiedzieć się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
wypowiedzieć się: _: : perf: subj{np(str)} + {cp(int)}
wypowiedzieć się: _: : perf: subj{np(str)} + {or}
wypowiedzieć się: _: : perf: subj{np(str)} + {prepnp(co do,gen)}
wypowiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wypowiedzieć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)}
wypowiedzieć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
wypowiedzieć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wypowiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypowiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wypożyczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wypożyczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wypożyczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wypożyczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {prepnp(za,acc)}
wypożyczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wypożyczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wypożyczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wypożyczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {prepnp(za,acc)}
wypracować się: _: : perf: subj{np(str)}
wypracować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypracować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wypracowywać się: _: : imperf: subj{np(str)}
wypracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wypraszać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: _: : imperf: subj{np(str)} + {cp(jakoby)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {xp(locat)}
wypraszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
wypraszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(żeby)}
wypraszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(żeby)}
wypraszać: _: : imperf: subj{np(str)} + {np(str)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {np(inst)} + {prepnp(u,gen)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(od,gen)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {xp(locat)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wypraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprężać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wyprężać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprężyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyprężyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprodukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprodukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wyprodukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wyprodukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprofilować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypromować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wypromować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wypromować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wypromować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wyprosić: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {xp(locat)}
wyprosić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
wyprosić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(żeby)}
wyprosić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(żeby)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {np(inst)} + {prepnp(u,gen)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(od,gen)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {xp(locat)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wyprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprostować się: _: : perf: subj{np(str)} + {np(dat)}
wyprostować: _: : perf: subj{np(str)} + {cp(że)}
wyprostować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
wyprostować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprostować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wyprowadzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wyprowadzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wyprowadzać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
wyprowadzać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pole',natr)}
wyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wyprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
wyprowadzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wyprowadzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wyprowadzić się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
wyprowadzić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pole',natr)}
wyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wyprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
wypróbować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
wypróbować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wypróbować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
wypróbować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {prepnp(na,loc)}
wypróbować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wypróbować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
wypróbować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
wypróbowywać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
wypróbowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wypróbowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
wypróbowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {prepnp(na,loc)}
wypróbowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wypróbowywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
wypróbowywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
wyprzeć się: _: : perf: subj{np(str)} + {cp(jakoby)}
wyprzeć się: _: : perf: subj{np(str)} + {cp(że)}
wyprzeć się: _: : perf: subj{np(str)} + {cp(żeby)}
wyprzeć się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
wyprzeć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {or}
wyprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)} + {xp(abl)}
wyprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyprzedać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyprzedać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyprzedawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyprzedawać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
wyprzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
wyprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
wyprzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
wypunktować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypunktować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wypunktować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wypuszczać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypuścić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypuścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypychać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypychać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wypychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyrabiać się: _: : imperf: subj{np(str)} + {np(dat)}
wyrabiać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
wyrabiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wyrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyradzać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wyradzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyrastać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrastać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyrastać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wyrazić się: _: : perf: subj{np(str)} + controller{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + controllee{xp(mod)}
wyrazić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(u,gen)}
wyrazić się: _: : perf: subj{np(str)} + {or}
wyrazić się: _: : perf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrazić się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
wyrazić: _: : perf: subj{np(str)} + {cp(że)}
wyrazić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
wyrazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wyrazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
wyrazić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrażać się: _: : imperf: subj{np(str)} + controller{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + controllee{xp(mod)}
wyrażać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(u,gen)}
wyrażać się: _: : imperf: subj{np(str)} + {or}
wyrażać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrażać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
wyrażać: _: : imperf: subj{np(str)} + {cp(że)}
wyrażać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
wyrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wyrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
wyrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrąbać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyrąbać się: _: : perf: subj{np(str)} + {xp(adl)}
wyrąbać się: _: : perf: subj{np(str)} + {xp(locat)}
wyrąbać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyrąbać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
wyrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyrąbywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyrąbywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
wyrąbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyrąbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyrecytować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyrecytować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyrecytować: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyrecytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyregulować się: _: : perf: subj{np(str)}
wyregulować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrejestrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyrejestrować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wyreżyserować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyreżyserować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
wyręczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wyręczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
wyręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyręczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wyręczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
wyręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyrobić się: _: : perf: subj{np(str)} + {advp(misc)}
wyrobić się: _: : perf: subj{np(str)} + {np(dat)}
wyrobić się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
wyrobić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyrobić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyrobić: _: : perf: subj{np(str)} + {advp(misc)}
wyrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
wyrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyrodzić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wyrodzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyrokować: _: : imperf: subj{np(str)} + {comprepnp(co do)}
wyrokować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wyrokować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
wyrokować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
wyrokować: _: : imperf: subj{np(str)} + {cp(int)}
wyrokować: _: : imperf: subj{np(str)} + {cp(że)}
wyrokować: _: : imperf: subj{np(str)} + {or}
wyrokować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wyrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyrosnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wyrównać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wyrównać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wyrównać: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'rachunek',atr)} + {prepnp(z,inst)}
wyrównać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
wyrównać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
wyrównywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wyrównywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wyrównywać: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'rachunek',atr)} + {prepnp(z,inst)}
wyrównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
wyrównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
wyróżniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wyróżniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(spośród,gen)}
wyróżniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wyróżniać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(od,gen)}
wyróżniać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(spośród,gen)}
wyróżniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyróżnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wyróżnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(spośród,gen)}
wyróżnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyróżnić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(od,gen)}
wyróżnić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(spośród,gen)}
wyróżnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyrugować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyruszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wyruszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wyruszać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyruszyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wyruszyć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
wyruszyć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wyrwać się: _: : perf: subj{cp(że)} + {np(dat)}
wyrwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrwać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wyrwać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyrwać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyrwać się: _: : perf: subj{or} + {np(dat)} + {prepnp(z,gen)}
wyrwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyrwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyrwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyrwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {preplexnp(z,inst,pl,'korzeń',natr)}
wyrwać: _: : perf: subj{np(str)} + {xp(adl)}
wyryć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyryć się: _: : perf: subj{np(str)} + {np(gen)} + {preplexnp(na,acc,sg,'blacha',natr)}
wyryć się: _: : perf: subj{np(str)} + {np(gen)} + {preplexnp(na,acc,sg,'pamięć',natr)}
wyryć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyryć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'blacha',natr)}
wyryć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pamięć',natr)}
wyrywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wyrywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wyrywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyrywać się: _: : imperf: subj{or} + {np(dat)} + {prepnp(z,gen)}
wyrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {preplexnp(z,inst,pl,'korzeń',natr)}
wyrywać: _: : imperf: subj{np(str)} + {xp(adl)}
wyrządzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wyrządzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wyrzec się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
wyrzec się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(dla,gen)}
wyrzec: _: : perf: subj{np(str)} + {cp(że)}
wyrzec: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
wyrzec: _: : perf: subj{np(str)} + {or}
wyrzekać się: _: : imperf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
wyrzekać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(dla,gen)}
wyrzekać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
wyrzekać: _: : imperf: subj{np(str)} + {or}
wyrzekać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wyrzekać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wyrzeźbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyrzeźbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyrzucać: _: : imperf: {np(dat)} + {np(str)}
wyrzucać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyrzucać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,że)}
wyrzucać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wyrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'błoto',natr)}
wyrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)} + {xp(adl)}
wyrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wyrzucać: _: : imperf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wyrzucić: _: : perf: {np(dat)} + {np(str)}
wyrzucić: _: : perf: subj{np(str)} + {cp(int)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucić: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyrzucić: _: : perf: subj{np(str)} + {np(dat)} + {ncp(str,że)}
wyrzucić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
wyrzucić: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'błoto',natr)}
wyrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)} + {xp(adl)}
wyrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wyrzucić: _: : perf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wyrzynać się: _: : imperf: subj{np(str)} + {np(dat)}
wyrzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyrzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyrzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyrzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(do,gen,sg,'noga',natr)}
wyrzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(w,acc,sg,'pień',natr)}
wyrżnąć się: _: : perf: subj{np(str)} + {np(dat)}
wyrżnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wyrżnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
wyrżnąć się: _: : perf: subj{np(str)} + {xp(adl)}
wyrżnąć się: _: : perf: subj{np(str)} + {xp(locat)}
wyrżnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
wyrżnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wyrżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyrżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyrżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyrżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(do,gen,sg,'noga',natr)}
wyrżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(w,acc,sg,'pień',natr)}
wyrżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wyschnąć: _: : perf: {np(dat)} + {xp(locat)}
wyschnąć: _: : perf: subj{np(str)} + {np(dat)}
wyselekcjonować: _: : perf: subj{np(str)} + {cp(int)}
wyselekcjonować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyselekcjonować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysiadać: _: : imperf: subj{np(str)} + {np(dat)}
wysiadać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
wysiadać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wysiadywać: _: : imperf: subj{np(str)} + obj{np(str)}
wysiadywać: _: : imperf: subj{np(str)} + {xp(locat)}
wysiąść: _: : perf: subj{np(str)} + {np(dat)}
wysiąść: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
wysiąść: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wysiedlać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wysiedlić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wysiedzieć się: _: : perf: subj{np(str)} + {xp(locat)}
wysiedzieć: _: : perf: subj{np(str)} + obj{np(str)}
wysiedzieć: _: : perf: subj{np(str)} + {xp(locat)}
wysikać się: _: : perf: subj{np(str)} + {xp(adl)}
wysikać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyskakiwać: _: : imperf: subj{cp(że)} + {np(dat)}
wyskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyskakiwać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wyskakiwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyskakiwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(perl)}
wyskakiwać: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wyskakiwać: _: : imperf: subj{or} + {np(dat)}
wyskoczyć: _: : perf: subj{cp(że)} + {np(dat)}
wyskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyskoczyć: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wyskoczyć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyskoczyć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(perl)}
wyskoczyć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wyskoczyć: _: : perf: subj{or} + {np(dat)}
wysłuchać: _: : perf: subj{np(str)} + obj{cp(int)}
wysłuchać: _: : perf: subj{np(str)} + obj{cp(jak)}
wysłuchać: _: : perf: subj{np(str)} + obj{cp(że)}
wysłuchać: _: : perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)}
wysłuchać: _: : perf: subj{np(str)} + obj{np(str)}
wysłuchiwać: _: : imperf: subj{np(str)} + obj{cp(int)}
wysłuchiwać: _: : imperf: subj{np(str)} + obj{cp(jak)}
wysłuchiwać: _: : imperf: subj{np(str)} + obj{cp(że)}
wysłuchiwać: _: : imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)}
wysłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)}
wysługiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wysługiwać się: _: : imperf: subj{np(str)} + {np(inst)}
wysługiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysługiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
wysłużyć się: _: : perf: subj{np(str)} + {np(dat)}
wysłużyć się: _: : perf: subj{np(str)} + {np(inst)}
wysłużyć się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
wysłużyć się: _: : perf: subj{np(str)} + {xp(locat)}
wysłużyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysłużyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
wyspać się: _: : perf: subj{np(str)}
wyspecjalizować się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
wyspowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyspowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyspowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyspowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wyspowiadać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wyspowiadać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wyspowiadać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
wyspowiadać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wyspowiadać się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wyspowiadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wyssać: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,sg,'palec',atr)}
wyssać: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('z mlekiem matki')}
wyssać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wystarać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(u,gen)}
wystarać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)} + {cp(żeby)}
wystarać się: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(u,gen)}
wystarać się: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)} + {cp(żeby)}
wystarczać: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc)}
wystarczać: _: : imperf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
wystarczać: _: : imperf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: _: : imperf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
wystarczać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
wystarczać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystarczyć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(na,acc)}
wystarczyć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
wystarczyć: _: : perf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: _: : perf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystartować: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wystartować: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wystartować: _: : perf: subj{np(str)} + {xp(abl)}
wystawać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wystawać: _: : imperf: subj{np(str)} + {xp(adl)}
wystawać: _: : imperf: subj{np(str)} + {xp(locat)}
wystawiać się: _: : imperf: subj{np(str)} + {xp(locat)}
wystawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wystawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wystawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wystawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wystawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wystawiać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wystawić się: _: : perf: subj{np(str)} + {xp(locat)}
wystawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wystawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wystawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wystawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wystawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wystawić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wystąpić: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wystąpić: _: : perf: subj{ncp(str,że)} + {prepnp(u,gen)}
wystąpić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(u,gen)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wystąpić: _: : perf: subj{np(str)} + {prepnp(z,gen)}
występować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
występować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
występować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
występować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
występować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
występować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
występować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
występować: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
występować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
występować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
występować: _: : imperf: subj{np(str)} + {xp(locat)}
wystosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wystosowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wystraszać się: _: : imperf: subj{np(str)} + {cp(że)}
wystraszać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
wystraszać się: _: : imperf: subj{np(str)} + {np(inst)}
wystraszać się: _: : imperf: subj{np(str)} + {or}
wystraszać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
wystraszać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wystraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(abl)}
wystraszyć się: _: : perf: subj{np(str)} + {cp(że)}
wystraszyć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
wystraszyć się: _: : perf: subj{np(str)} + {np(inst)}
wystraszyć się: _: : perf: subj{np(str)} + {or}
wystraszyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
wystraszyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wystraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(abl)}
wystrugać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wystrugać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wystrzelić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
wystrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wystrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wystrzelić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wystrzelić: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wystrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wystrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wystrzyc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(mod)}
wystrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wystrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wystrzygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(mod)}
wystudiować: _: : perf: subj{np(str)} + {cp(int)}
wystudiować: _: : perf: subj{np(str)} + {cp(że)}
wystudiować: _: : perf: subj{np(str)} + obj{np(str)}
wysunąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wysunąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysunąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wysuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wysuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wysychać: _: : imperf: {np(dat)} + {xp(locat)}
wysychać: _: : imperf: subj{np(str)} + {np(dat)}
wysypać się: _: : perf: subj{np(str)} + {cp(że)}
wysypać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wysypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wysypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysysać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,sg,'palec',atr)}
wysysać: _: : imperf: subj{np(str)} + obj{np(str)} + {fixed('z mlekiem matki')}
wysysać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyszabrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyszabrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyszczególnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyszczególnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyszczególnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyszczerbić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wyszczerbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyszczerbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
wyszeptać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
wyszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wyszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wyszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wyszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wyszkolić się: _: : perf: subj{np(str)} + {cp(int)}
wyszkolić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wyszkolić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wyszkolić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wyszkolić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyszkolić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
wyszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wyszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyszorować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wyszorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyszturchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyszukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wyszukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
wyszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wyszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
wyszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyśmiać się: _: : perf: subj{np(str)}
wyśmiać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
wyśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wyśmiewać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
wyśpiewać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyśpiewać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyśpiewać: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyśpiewać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyśpiewywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyśpiewywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyśpiewywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wyśpiewywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyświetlać się: _: : imperf: subj{cp(int)} + {np(dat)} + {xp(locat)}
wyświetlać się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
wyświetlać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(locat)}
wyświetlać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {xp(locat)}
wyświetlać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {xp(locat)}
wyświetlać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(locat)}
wyświetlić się: _: : perf: subj{cp(int)} + {np(dat)} + {xp(locat)}
wyświetlić się: _: : perf: subj{cp(że)} + {np(dat)} + {xp(locat)}
wyświetlić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(locat)}
wyświetlić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {xp(locat)}
wyświetlić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {xp(locat)}
wyświetlić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(locat)}
wyświęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyświęcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wytaczać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wytapetować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
wytapetować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wytapetować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
wytapetować: _: : perf: subj{np(str)} + {refl}
wytapetować: _: : perf: subj{np(str)} + {xp(locat)} + {xp(mod)}
wytargować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
wytargować się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
wytargować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(od,gen)}
wytargować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(u,gen)}
wytargować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wytargować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wytargować: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wytargować: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(żeby)}
wytargować: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
wytargować: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(żeby)}
wytarmosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wytarmosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wytatuować się: _: : perf: subj{np(str)}
wytatuować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wytępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wytknąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)} + {lexnp(inst,_,'palec',natr)}
wytknąć: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
wytknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {lexnp(inst,_,'palec',natr)}
wytknąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wytłumaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wytłumaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wytłumaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wytłumaczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wytłumaczyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wytłumaczyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
wytłumaczyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wytłumaczyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
wytłumaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wytłumaczyć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
wytłumaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wytłumaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytoczyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wytrącać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wytrącać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
wytrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wytrącać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(z,gen)}
wytrącić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wytrącić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
wytrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wytrącić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(z,gen)}
wytropić: _: : perf: subj{np(str)} + {cp(int)}
wytropić: _: : perf: subj{np(str)} + {cp(że)}
wytropić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
wytropić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wytropić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wytrwać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(dur)}
wytrwać: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
wytrząsać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
wytrząsać: _: : imperf: subj{np(str)} + {np(inst)}
wytrząsać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wytrząsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wytrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wytrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wytrzeć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wytrzeć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
wytrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wytrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
wytrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wytrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wytrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepnp(w,acc)} + {prepnp(z,gen)}
wytrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wytrzeć: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
wytrzeć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wytrzeźwieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wytrzymać: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
wytrzymać: _: : perf: subj{np(str)} + {np(str)} + {xp(dur)}
wytrzymać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)}
wytrzymywać: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
wytrzymywać: _: : imperf: subj{np(str)} + {np(str)} + {xp(dur)}
wytrzymywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)}
wytuszować: _: : perf: subj{np(str)} + {refl}
wytwarzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wytwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytworzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wytworzyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wytworzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytyczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wytyczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wytykać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)} + {lexnp(inst,_,'palec',natr)}
wytykać: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
wytykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {lexnp(inst,_,'palec',natr)}
wytykać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wytypować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wytypować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wytypować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wywabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {preplexnp(pod,inst,sg,'pozór',atr)}
wywabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {preplexnp(pod,inst,sg,'pretekst',atr)}
wywabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wywabić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {preplexnp(pod,inst,sg,'pozór',atr)}
wywabić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {preplexnp(pod,inst,sg,'pretekst',atr)}
wywalać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wywalać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wywalać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wywalać się: _: : imperf: subj{np(str)} + {xp(locat)}
wywalać: _: : imperf: {np(dat)} + {cp(że)}
wywalać: _: : imperf: {np(dat)} + {np(str)}
wywalać: _: : imperf: {np(dat)} + {or}
wywalać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wywalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {xp(abl)}
wywalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wywalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
wywalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wywalczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wywalczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wywalczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst); ncp(inst,że)}
wywalczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wywalczyć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {cp(żeby)}
wywalić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wywalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wywalić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wywalić się: _: : perf: subj{np(str)} + {xp(locat)}
wywalić: _: : perf: {np(dat)} + {cp(że)}
wywalić: _: : perf: {np(dat)} + {np(str)}
wywalić: _: : perf: {np(dat)} + {or}
wywalić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wywalić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {xp(abl)}
wywalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wywalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
wywalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
wyważać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyważyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wywęszyć: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
wywęszyć: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
wywęszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
wywęszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
wywiązać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywiązywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywierać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)}
wywierać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(na,loc)}
wywierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wywierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wywiercić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wywiercić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wywiesić się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
wywiesić się: _: : perf: subj{np(str)} + {xp(adl)}
wywiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
wywiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wywiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wywieszać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
wywieszać się: _: : imperf: subj{np(str)} + {xp(adl)}
wywieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
wywieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wywieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wywieść: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
wywieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,acc,pl,'manowiec',natr)}
wywieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(w,acc,sg,'pole',natr)}
wywieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
wywieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wywieść: _: : perf: subj{np(str)} + {or}
wywieść: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {cp(int)}
wywieść: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {cp(że)}
wywieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wywieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wywieźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywnioskować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wywnioskować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnioskować: _: : perf: subj{np(str)} + {or}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(żeby2)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wywnioskować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(żeby2)}
wywodzić się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
wywodzić się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywodzić się: _: : imperf: subj{np(str)} + {xp(abl)}
wywodzić: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
wywodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,acc,pl,'manowiec',natr)}
wywodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(w,acc,sg,'pole',natr)}
wywodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
wywodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wywodzić: _: : imperf: subj{np(str)} + {or}
wywodzić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {cp(int)}
wywodzić: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {cp(że)}
wywołać: _: : perf: subj{ncp(str,int)} + obj{np(str)}
wywołać: _: : perf: subj{ncp(str,że)} + {np(str)} + {prepnp(wśród,gen)}
wywołać: _: : perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
wywołać: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wywołać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(wśród,gen)}
wywołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywołać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wywołać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wywołać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wywołać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywoływać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
wywoływać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wywoływać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(wśród,gen)}
wywoływać: _: : imperf: subj{np(str)} + obj{ncp(str,że)}
wywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wywoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywozić: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,pl,'taczka',natr)}
wywozić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wywracać się: _: : imperf: subj{np(str)} + {np(dat)}
wywracać: _: : imperf: subj{np(str)} + {lexnp(inst,pl,'oko',atr)}
wywracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,pl,'noga',natr)} + {preplexnp(do,gen,sg,'góra',natr)}
wywracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wywrócić się: _: : perf: subj{np(str)} + {np(dat)}
wywrócić: _: : perf: subj{np(str)} + {lexnp(inst,pl,'oko',atr)}
wywrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wywrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(do,gen,sg,'góra',natr)}
wywrzeć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)}
wywrzeć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(na,loc)}
wywrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wywrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wywyższać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,acc)}
wywyższać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(ponad,acc)}
wywyższać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywyższać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
wywyższać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
wywyższyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(nad,acc)}
wywyższyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(ponad,acc)}
wywyższyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywyższyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
wywyższyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
wyzbyć się: _: : perf: subj{np(str)} + {np(gen)}
wyzdrowieć: _: : perf: subj{np(str)} + {prepnp(po,loc)}
wyzdrowieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyzierać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(perl)}
wyzierać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyziębiać się: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
wyziębiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wyziębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyziębić się: _: : perf: {prepnp(od,gen)} + {xp(locat)}
wyziębić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wyziębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyznaczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyznaczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
wyznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wyznaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyznaczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
wyznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wyznać się: _: : perf: subj{np(str)} + {or}
wyznać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wyznać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyznać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyznać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyznać: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyznać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wyznawać się: _: : imperf: subj{np(str)} + {or}
wyznawać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wyznawać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wyznawać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyznawać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyznawać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wyznawać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wyzwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyzwać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wyzwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyzwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyzwalać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wyzwalać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wyzwalać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
wyzwalać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(spod,gen)} + {refl}
wyzwalać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wyzwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyzwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spod,gen)}
wyzwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyzwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyzwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzwolić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wyzwolić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyzwolić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
wyzwolić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(spod,gen)} + {refl}
wyzwolić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wyzwolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyzwolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spod,gen)}
wyzwolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyzwolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyzwolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
wyzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyżłobić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyżłobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyżyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
wyżyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyżyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wyżyć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wyżyć: _: : perf: subj{np(str)} + {prepnp(za,acc)}
wyżyć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyżyć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
wyżywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
wyżywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyżywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wyżywiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wyżywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyżywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wyżywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyżywiać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
wyżywiać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {refl}
wyżywić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wyżywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyżywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wyżywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyżywić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
wyżywić: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {refl}
wzbić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wzbić się: _: : perf: subj{np(str)} + {xp(locat)}
wzbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wzbić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wzbijać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wzbijać się: _: : imperf: subj{np(str)} + {xp(locat)}
wzbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wzbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wzbogacać się: _: : imperf: subj{np(str)} + {np(inst)}
wzbogacać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wzbogacać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
wzbogacać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wzbogacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wzbogacać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wzbogacać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wzbogacić się: _: : perf: subj{np(str)} + {np(inst)}
wzbogacić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wzbogacić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
wzbogacić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wzbogacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wzbogacić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wzbogacić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wzbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wzbudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wzbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wzbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wzburzać się: _: : imperf: subj{np(str)} + {cp(że)}
wzburzać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wzburzać się: _: : imperf: subj{np(str)} + {or}
wzburzać: _: : imperf: subj{cp(gdy)} + {np(str)}
wzburzać: _: : imperf: subj{cp(int)} + {np(str)}
wzburzać: _: : imperf: subj{cp(jak)} + {np(str)}
wzburzać: _: : imperf: subj{cp(jeśli)} + {np(str)}
wzburzać: _: : imperf: subj{cp(kiedy)} + {np(str)}
wzburzać: _: : imperf: subj{cp(że)} + {np(str)}
wzburzać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
wzburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wzburzyć się: _: : perf: subj{np(str)} + {cp(że)}
wzburzyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wzburzyć się: _: : perf: subj{np(str)} + {or}
wzburzyć: _: : perf: subj{cp(gdy)} + {np(str)}
wzburzyć: _: : perf: subj{cp(int)} + {np(str)}
wzburzyć: _: : perf: subj{cp(jak)} + {np(str)}
wzburzyć: _: : perf: subj{cp(jeśli)} + {np(str)}
wzburzyć: _: : perf: subj{cp(kiedy)} + {np(str)}
wzburzyć: _: : perf: subj{cp(że)} + {np(str)}
wzburzyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
wzburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wzdąć się: _: : perf: subj{np(str)} + {np(dat)}
wzdąć się: _: : perf: subj{np(str)} + {np(inst)}
wzdąć: _: : perf: {np(dat)} + {np(str)}
wzdąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wzdychać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wzdychać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wzdychać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wzdychać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,żeby)}
wzdychać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wzdychać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
wzdychać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wzdymać się: _: : imperf: subj{np(str)} + {np(dat)}
wzdymać się: _: : imperf: subj{np(str)} + {np(inst)}
wzdymać: _: : imperf: {np(dat)} + {np(str)}
wzdymać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wziąć się: _: : perf: subj{np(str)} + {preplexnp(w,acc,pl,'karb',natr)}
wziąć się: _: : perf: subj{np(str)} + {preplexnp(w,acc,pl,'ryza',natr)}
wziąć się: _: : perf: subj{np(str)} + {preplexnp(w,acc,sg,'garść',natr)}
wziąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wziąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wziąć się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
wziąć się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
wziąć się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wziąć się: _: : perf: subj{np(str)} + {xp(abl)}
wziąć: _: : perf: {np(str)} + {prepnp(na,acc)}
wziąć: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(do,gen,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + {lexnp(part,sg,'woda',natr)} + {preplexnp(w,acc,pl,'usta',natr)}
wziąć: _: : perf: subj{np(str)} + {ncp(str,że)} + {preplexnp(do,gen,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + {ncp(str,że)} + {preplexnp(na,acc,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + {np(str)}
wziąć: _: : perf: subj{np(str)} + {np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(do,gen)} + {lexnp(dat,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(do,gen,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(na,acc,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
wziąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
wziąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
wziąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {preplexnp(pod,acc,sg,'uwaga',atr)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wziąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wziąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wziąć: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,sg,'góra',natr)}
wziąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'łapa',natr)}
wziąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'skóra',natr)}
wziąć: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
wziąć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(str,sg,'ślub',atr)}
wzmacniać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wzmacniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wzmacniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wzmacniać: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {refl}
wzmagać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
wzmagać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wzmagać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wzmagać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
wzmiankować: _: : imperf: subj{np(str)} + {cp(int)}
wzmiankować: _: : imperf: subj{np(str)} + {cp(że)}
wzmiankować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wzmiankować: _: : imperf: subj{np(str)} + {or}
wzmiankować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wzmocnić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wzmocnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wzmocnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wzmocnić: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
wzmóc się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
wzmóc się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wzmóc: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wzmóc: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
wznawiać się: _: : imperf: subj{np(str)}
wznawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wznieść się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wznieść się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wznieść się: _: : perf: subj{np(str)} + {prepnp(ponad,acc)}
wznieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wznieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wznosić się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wznosić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wznosić się: _: : imperf: subj{np(str)} + {prepnp(ponad,acc)}
wznosić się: _: : imperf: subj{np(str)} + {xp(locat)}
wznosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wznosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wznowić się: _: : perf: subj{np(str)}
wznowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wzorować się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
wzorować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
wzrastać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wzrastać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wzrastać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wzrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wzrosnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wzrosnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wzruszać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
wzruszać się: _: : imperf: subj{np(str)} + {or}
wzruszać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
wzruszać: _: : imperf: subj{cp(że); ncp(str,że)} + obj{np(str)}
wzruszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wzruszać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(inst,pl,'ramię',natr)}
wzruszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
wzruszyć się: _: : perf: subj{np(str)} + {or}
wzruszyć się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
wzruszyć: _: : perf: subj{cp(że); ncp(str,że)} + {np(str)}
wzruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wzruszyć: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(inst,pl,'ramię',atr)}
wzywać: _: : imperf: subj{np(str)} + {np(gen)} + {np(inst)}
wzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {xp(adl)}
wzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
wzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
wżenić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zaabsorbować: _: : perf: subj{cp(int)} + {np(str)}
zaabsorbować: _: : perf: subj{cp(żeby)} + {np(str)}
zaabsorbować: _: : perf: subj{cp(że)} + {np(str)}
zaabsorbować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + obj{np(str)}
zaabsorbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zaabsorbować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)}
zaadaptować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaadaptować się: _: : perf: subj{np(str)} + {xp(locat)}
zaadaptować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zaadaptować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaadaptować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaadresować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaadresować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaakcentować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
zaakcentować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(inst)}
zaakcentować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
zaakcentować: _: : perf: subj{np(str)} + {or}
zaakceptować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zaakceptować: _: : perf: subj{np(str)} + obj{cp(int)}
zaakceptować: _: : perf: subj{np(str)} + obj{cp(że)}
zaakceptować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zaakceptować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zaaklimatyzować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaaklimatyzować się: _: : perf: subj{np(str)} + {xp(locat)}
zaaklimatyzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaaklimatyzować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaalarmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {comprepnp(w kwestii)}
zaalarmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {comprepnp(w sprawie)}
zaalarmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zaalarmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zaalarmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaalarmować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zaanektować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaanektować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zaanektować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaanektować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zaangażować się: _: : perf: subj{np(str)} + {comprepnp(na rzecz)}
zaangażować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaangażować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zaangażować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaangażować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaangażować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaapelować: _: : perf: subj{np(str)} + {preplexnp(od,gen,_,'wyrok',atr)}
zaapelować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
zaapelować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zaapelować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zaapelować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zaapelować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
zaaplikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
zaaplikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zaaplikować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zaaplikować: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zaaranżować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaaranżować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zaaranżować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaaranżować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
zaatakować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zaatakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zaatakować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zabalsamować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zabalsamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabarykadować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
zabarykadować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabarykadować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zabawić się: _: : perf: subj{np(str)} + {np(inst)}
zabawić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zabawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabawić: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
zabezpieczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabezpieczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabezpieczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabezpieczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabezpieczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabezpieczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zabić: _: : perf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {prepnp(z,gen)} + {advp(misc)}
zabić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
zabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabiec: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
zabiec: _: : perf: subj{np(str)} + {xp(adl)}
zabiedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabiegać się: _: : imperf: subj{np(str)}
zabiegać: _: : imperf: subj{np(str)} + {cp(żeby)}
zabiegać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
zabiegać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zabiegać: _: : imperf: subj{np(str)} + {xp(adl)}
zabijać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zabijać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
zabijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zablokować się: _: : perf: subj{np(str)} + {np(dat)}
zablokować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabłądzić: _: : perf: subj{np(str)} + {xp(adl)}
zabłądzić: _: : perf: subj{np(str)} + {xp(locat)}
zabłysnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zabłysnąć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zabrać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zabrać się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
zabrać się: _: : perf: subj{np(str)} + {xp(adl)}
zabrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zabrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zabrać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zabrać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zabraknąć: _: : perf: {np(dat)} + {np(gen)} + {cp(żeby)}
zabraknąć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zabraknąć: _: : perf: {np(dat)} + {prepnp(dla,gen)} + {lexnp(gen,pl,'słowo',atr)}
zabraknąć: _: : perf: {np(dat)} + {prepnp(na,acc)} + {lexnp(gen,pl,'słowo',atr)}
zabraknąć: _: : perf: {np(gen)} + {xp(locat)}
zabraniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zabraniać: _: : imperf: subj{np(str)} + {np(dat)} + {ncp(gen,żeby)}
zabraniać: _: : imperf: subj{np(str)} + obj,controllee{np(gen); infp(_)} + controller{np(dat)}
zabronić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zabronić: _: : perf: subj{np(str)} + {np(dat)} + {ncp(gen,żeby)}
zabronić: _: : perf: subj{np(str)} + obj,controllee{np(gen); infp(_)} + controller{np(dat)}
zabrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zabrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zabrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
zabrzmieć: _: : perf: subj,controller{np(str)} + controllee{or}
zabrzmieć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'usta',ratr)}
zabrzmieć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',ratr)}
zabrzmieć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(dla,gen)}
zabrzmieć: _: : perf: subj,controller{np(str); ncp(str,że)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',ratr)}
zabrzmieć: _: : perf: subj,controller{or} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',ratr)}
zabrzmieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(w,loc,pl,'ucho',ratr)}
zabrzmieć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaburczeć: _: : perf: {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
zaburczeć: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(na temat)}
zaburczeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
zaburczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zaburczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zaburczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zaburczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zaburczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zaburczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zachcieć się: _: : perf: controller{np(dat)} + controllee{infp(_)}
zachcieć się: _: : perf: {np(dat)} + {cp(żeby)}
zachcieć się: _: : perf: {np(dat)} + {np(gen)}
zachcieć się: _: : perf: {np(dat)} + {xp(adl)}
zachcieć: _: : perf: controller{np(str)} + controllee{infp(_)}
zachcieć: _: : perf: subj{np(str)} + {cp(żeby)}
zachcieć: _: : perf: subj{np(str)} + {np(gen)}
zachcieć: _: : perf: subj{np(str)} + {xp(adl)}
zachciewać się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
zachciewać się: _: : imperf: {np(dat)} + {cp(żeby)}
zachciewać się: _: : imperf: {np(dat)} + {np(gen)}
zachciewać się: _: : imperf: {np(dat)} + {xp(adl)}
zachęcać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zachęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zachęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zachęcić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zachęcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zachęcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zachłysnąć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zachłysnąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zachłystywać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
zachłystywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zachodzić: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(w,acc,sg,'głowa',natr)}
zachodzić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zachodzić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(za,acc,sg,'skóra',natr)}
zachodzić: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
zachodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zachodzić: _: : imperf: subj{np(str)} + {preplexnp(w,acc,sg,'głowa',natr)} + {or}
zachodzić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zachodzić: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zachodzić: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zachodzić: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
zachorować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
zachorować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zachować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zachować się: _: : perf: subj{np(str)} + {xp(locat)}
zachować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zachować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zachować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zachować: _: : perf: subj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)} + {refl}
zachowywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
zachowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
zachowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zachowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zachowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
zachowywać: _: : imperf: subj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)} + {refl}
zachrzęścić: _: : perf: {np(dat)} + {xp(locat)}
zachrzęścić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zachrzęścić: _: : perf: subj{np(str)} + {np(inst)}
zachwalać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
zachwalać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
zachwalać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zachwalać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zachwalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zachwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
zachwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zachwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zachwiać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zachwiać: _: : perf: subj{np(str)} + obj{np(inst)}
zachwiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zachwiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zachwycać się: _: : imperf: subj{np(str)} + {cp(int)}
zachwycać się: _: : imperf: subj{np(str)} + {cp(że)}
zachwycać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycać się: _: : imperf: subj{np(str)} + {or}
zachwycać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zachwycać: _: : imperf: subj{cp(gdy)} + {np(str)}
zachwycać: _: : imperf: subj{cp(int)} + {np(str)}
zachwycać: _: : imperf: subj{cp(jak)} + {np(str)}
zachwycać: _: : imperf: subj{cp(jeśli)} + {np(str)}
zachwycać: _: : imperf: subj{cp(kiedy)} + {np(str)}
zachwycać: _: : imperf: subj{cp(że)} + {np(str)}
zachwycać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zachwycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycić się: _: : perf: subj{np(str)} + {cp(int)}
zachwycić się: _: : perf: subj{np(str)} + {cp(że)}
zachwycić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycić się: _: : perf: subj{np(str)} + {or}
zachwycić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zachwycić: _: : perf: subj{cp(gdy)} + {np(str)}
zachwycić: _: : perf: subj{cp(int)} + {np(str)}
zachwycić: _: : perf: subj{cp(jak)} + {np(str)}
zachwycić: _: : perf: subj{cp(jeśli)} + {np(str)}
zachwycić: _: : perf: subj{cp(kiedy)} + {np(str)}
zachwycić: _: : perf: subj{cp(że)} + {np(str)}
zachwycić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zachwycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaciąć się: _: : perf: subj{np(str)} + {cp(że)}
zaciąć się: _: : perf: subj{np(str)} + {cp(żeby)}
zaciąć się: _: : perf: subj{np(str)} + {np(dat)}
zaciąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zaciąć się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zaciąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zaciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zaciąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zaciągać się: _: : imperf: subj{E}
zaciągać się: _: : imperf: subj{np(str)} + {np(inst)}
zaciągać się: _: : imperf: subj{np(str)} + {xp(adl)}
zaciągać: _: : imperf: subj{E} + {np(inst)} + {xp(abl)}
zaciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zaciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaciągać: _: : imperf: subj{np(str)} + {or}
zaciągać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
zaciągnąć się: _: : perf: subj{E}
zaciągnąć się: _: : perf: subj{np(str)} + {np(inst)}
zaciągnąć się: _: : perf: subj{np(str)} + {xp(adl)}
zaciągnąć: _: : perf: subj{E} + {np(inst)} + {xp(abl)}
zaciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zaciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaciążyć: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
zaciążyć: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zaciążyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaciążyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaciążyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zaciekawiać się: _: : imperf: subj{np(str)} + {cp(int)}
zaciekawiać się: _: : imperf: subj{np(str)} + {cp(że)}
zaciekawiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaciekawiać się: _: : imperf: subj{np(str)} + {or}
zaciekawiać: _: : imperf: subj{cp(int)} + {np(str)}
zaciekawiać: _: : imperf: subj{cp(że)} + {np(str)}
zaciekawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaciekawić się: _: : perf: subj{np(str)} + {cp(int)}
zaciekawić się: _: : perf: subj{np(str)} + {cp(że)}
zaciekawić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaciekawić się: _: : perf: subj{np(str)} + {or}
zaciekawić: _: : perf: subj{cp(int)} + {np(str)}
zaciekawić: _: : perf: subj{cp(że)} + {np(str)}
zaciekawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaciemniać się: _: : imperf: subj{np(str)} + {np(dat)}
zaciemniać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(dat)}
zaciemniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
zaciemnić się: _: : perf: subj{np(str)} + {np(dat)}
zaciemnić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(dat)}
zaciemnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
zacieniać się: _: : imperf: subj{np(str)} + {np(inst)}
zacieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zacienić się: _: : perf: subj{np(str)} + {np(inst)}
zacienić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zacierać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
zacierać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
zacierać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
zacierać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,pl,'ręka',natr)}
zacierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,pl,'ręka',natr)}
zacieśniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zacieśniać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
zacieśniać się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
zacieśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zacieśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zacieśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zacieśnić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zacieśnić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zacieśnić się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
zacieśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zacieśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zacieśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zacinać się: _: : imperf: subj{np(str)} + {np(dat)}
zacinać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
zacinać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zacinać: _: : imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
zacinać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zacinać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zacinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zacinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zacinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zacinać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zaciskać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zaciskać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
zaciskać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zaciskać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'pas',natr)}
zaciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
zaciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(wokół,gen)}
zaciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zacisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zacisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
zacisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zacisnąć: _: : perf: subj{np(str)} + {lexnp(gen,sg,'pas',natr)}
zacisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
zacisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(wokół,gen)}
zacisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zacytować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)} + {or}
zacytować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {or}
zacytować: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
zacytować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zaczaić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaczaić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zaczaić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaczaić: _: : perf: subj{np(str)} + {cp(int)}
zaczaić: _: : perf: subj{np(str)} + {cp(że)}
zaczaić: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
zaczaić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zacząć się: _: : perf: {prepnp(od,gen); prepncp(od,gen,że)}
zacząć się: _: : perf: subj{np(str)} + {np(dat)}
zacząć się: _: : perf: subj{np(str)} + {np(inst)}
zacząć się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zacząć się: _: : perf: subj{np(str)} + {xp(locat)}
zacząć się: _: : perf: subj{np(str)} + {xp(temp)}
zacząć: _: : perf: subj,controller{E} + controllee{infp(imperf)}
zacząć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zaczekać: _: : perf: subj{np(str)} + {prepnp(na,acc); cp(aż); cp(int); cp(jak); cp(kiedy); cp(że); cp(żeby); prepncp(na,acc,aż); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,kiedy); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)} + {xp(dur)}
zaczekać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(aż)} + {xp(dur)}
zaczekać: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
zaczepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zaczepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)}
zaczepiać się: _: : imperf: subj{np(str)} + {xp(locat)}
zaczepiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zaczepiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zaczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zaczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zaczepić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zaczepić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)}
zaczepić się: _: : perf: subj{np(str)} + {xp(locat)}
zaczepić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zaczepić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zaczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zaczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zaczernić się: _: : perf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
zaczernić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaczernić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaczernić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaczernieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaczernieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaczerpnąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(z,gen)}
zaczerpnąć: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(w,acc)}
zaczerpnąć: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl); xp(locat)}
zaczerpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zaczerpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl); xp(locat)}
zaczerwienić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zaczerwienić się: _: : perf: subj{np(str)} + {np(inst)}
zaczerwienić się: _: : perf: subj{np(str)} + {prepnp(po,acc)}
zaczerwienić: _: : perf: subj{np(str)} + obj{np(str)}
zaczerwienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaczerwienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zaczołgać się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zaczynać się: _: : imperf: subj{np(str)} + {np(dat)}
zaczynać się: _: : imperf: subj{np(str)} + {np(inst)}
zaczynać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zaczynać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zaczynać: _: : imperf: subj,controller{E} + controllee{infp(imperf)}
zaczynać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zaczynać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zaćmić się: _: : perf: {np(dat)} + {xp(locat)}
zaćmić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaćmić: _: : perf: {np(str)}
zaćmić: _: : perf: subj{np(str)} + {np(str)}
zaćmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaćmiewać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zaćmiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zadać: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
zadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadawać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zadawać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
zadawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadąć: _: : perf: {np(inst)} + {xp(locat)}
zadąć: _: : perf: subj{np(str)} + {np(inst)}
zadąć: _: : perf: subj{np(str)} + obj{np(str)}
zadąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zadąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zadąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zadąć: _: : perf: subj{np(str)} + {xp(perl)}
zadbać: _: : perf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
zadebiutować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(inst)} + {xp(locat)}
zadecydować się: _: : perf: subj{cp(int)}
zadecydować się: _: : perf: subj{np(str)}
zadecydować: _: : perf: subj{np(str)} + {advp(pron)}
zadecydować: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zadecydować: _: : perf: subj{np(str)} + {cp(int)}
zadecydować: _: : perf: subj{np(str)} + {cp(że)}
zadecydować: _: : perf: subj{np(str)} + {cp(żeby)}
zadecydować: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zadecydować: _: : perf: subj{np(str)} + {or}
zadecydować: _: : perf: subj{np(str)} + {prepncp(o,loc,żeby)}
zadedykować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zadeklarować się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zadeklarować się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
zadeklarować się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zadeklarować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zadeklarować się: _: : perf: subj{np(str)} + {comprepnp(co do)}
zadeklarować się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zadeklarować się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
zadeklarować się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zadeklarować się: _: : perf: subj{np(str)} + {cp(int)}
zadeklarować się: _: : perf: subj{np(str)} + {cp(że)}
zadeklarować się: _: : perf: subj{np(str)} + {cp(żeby)}
zadeklarować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zadeklarować się: _: : perf: subj{np(str)} + {or}
zadeklarować się: _: : perf: subj{np(str)} + {preplexnp(po,loc,sg,'strona',ratr)}
zadeklarować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zadeklarować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)}
zadeklarować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zadeklarować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zadeklarować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zadeklarować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zadeklarować: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zademonstrować: _: : perf: subj{np(str)} + {comprepnp(na rzecz)}
zademonstrować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
zademonstrować: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
zademonstrować: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(wobec,gen)}
zademonstrować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zademonstrować: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
zademonstrować: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(wobec,gen)}
zademonstrować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zademonstrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zademonstrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
zademonstrować: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zademonstrować: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zadłużyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)}
zadłużyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)} + {refl}
zadomowić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadomowić się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zadomowić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zadowalać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zadowalać: _: : imperf: subj{cp(że)} + {np(str)}
zadowalać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
zadowalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zadowolić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zadowolić: _: : perf: subj{cp(że)} + {np(str)}
zadowolić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
zadowolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zadrwić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zadrwić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
zadrwić: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zadrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zadrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zadrzeć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zadrżeć: _: : perf: subj{lexnp(str,sg,'ręka',natr)} + {np(dat)} + {cp(żeby2)}
zadrżeć: _: : perf: subj{np(str)} + {cp(czy)}
zadrżeć: _: : perf: subj{np(str)} + {cp(że)}
zadrżeć: _: : perf: subj{np(str)} + {cp(żeby)}
zadrżeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zadrżeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zadrżeć: _: : perf: subj{np(str)} + {or}
zadrżeć: _: : perf: subj{np(str)} + {preplexnp(w,loc,pl,'posada',natr)}
zadrżeć: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zadrżeć: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zadrżeć: _: : perf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
zadudnić: _: : perf: {np(dat)} + {xp(locat)}
zadudnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zadudnić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadudnić: _: : perf: subj{np(str)} + {np(inst)} + {or}
zadudnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zadudnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zadudnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zadudnić: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zadudnić: _: : perf: subj{or} + {np(dat)} + {xp(locat)}
zadumać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,jak); prepncp(nad,inst,że)}
zadziałać: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
zadziałać: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zadziałać: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
zadziałać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zadzierać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zadzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zadzierać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zadzwonić: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zadzwonić: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
zadzwonić: _: : perf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
zadzwonić: _: : perf: subj{np(str)} + {cp(int); cp(że); cp(żeby)} + {xp(abl)} + {xp(adl)}
zadzwonić: _: : perf: subj{np(str)} + {np(dat)}
zadzwonić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zadzwonić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
zadzwonić: _: : perf: subj{np(str)} + {np(inst)}
zadzwonić: _: : perf: subj{np(str)} + {preplexnp(do,gen,pl,'drzwi',atr)}
zadzwonić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zadzwonić: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)}
zadzwonić: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)}
zadzwonić: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {xp(abl)} + {xp(adl)}
zadźgać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zadźgać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zafałszować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zafascynować się: _: : perf: subj{np(str)} + {cp(int)}
zafascynować się: _: : perf: subj{np(str)} + {cp(że)}
zafascynować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zafascynować: _: : perf: subj{cp(int)} + {np(str)}
zafascynować: _: : perf: subj{cp(że)} + {np(str)}
zafascynować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
zafascynować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zafundować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zafundować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zagadać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(z,inst)}
zagadać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadać: _: : perf: subj{np(str)} + {prepadjp(po,postp)}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadać: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
zagadać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
zagadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zagadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zagadać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
zagadnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zagadnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {nonch}
zagadnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zagadywać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(z,inst)}
zagadywać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadywać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zagadywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
zagaić: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zagaić: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zagaić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zagaić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zagaić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zagaić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zagaić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zagaić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zagajać: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
zagajać: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
zagajać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zagajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zagajać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zagajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zagajać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zagajać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
zagapić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zagapić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zagapić się: _: : perf: subj{np(str)} + {xp(adl)}
zagarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zagarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zagazować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zagazować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagęszczać się: _: : imperf: subj{np(str)}
zagęszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagęścić się: _: : perf: subj{np(str)}
zagęścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zagiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zagiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
zagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zagiąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,sg,'parol',natr)}
zaginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zaginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zaginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zaginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
zaginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zaginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zaginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zaginać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,sg,'parol',natr)}
zaginąć: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
zaglądać: _: : imperf: subj{np(str)} + {cp(int)}
zaglądać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
zaglądać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaglądać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zaglądać: _: : imperf: subj{np(str)} + {xp(adl)}
zagłębiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zagłębiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
zagłębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zagłębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
zagłębić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zagłębić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
zagłębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zagłębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
zagłosować: _: : perf: subj{np(str)} + {cp(żeby)}
zagłosować: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zagłosować: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)}
zagłuszać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zagłuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
zagłuszyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zagłuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
zagnieździć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zagnieździć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagnieżdżać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zagnieżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagospodarować się: _: : perf: subj{np(str)} + {xp(locat)}
zagospodarować: _: : perf: subj{np(str)} + obj{np(str)}
zagościć się: _: : perf: subj{np(str)} + {xp(locat)}
zagościć: _: : perf: subj{np(str)} + {xp(adl)}
zagościć: _: : perf: subj{np(str)} + {xp(locat)}
zagrać: _: : perf: {np(dat)} + {prepnp(w,loc)}
zagrać: _: : perf: subj{np(str)} + {comprepnp(na rzecz)}
zagrać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zagrać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zagrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zagrać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(u,gen); prepnp(w,loc); xp(locat)}
zagrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zagrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zagrać: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(za,acc)}
zagrać: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zagradzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zagradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagrażać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
zagrażać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zagrodzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zagrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagrozić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)}
zagrozić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); cp(że); ncp(inst,że)}
zagrozić: _: : perf: subj{np(str)} + {np(dat)} + {or}
zagrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zagrywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zagrzać się: _: : perf: subj{np(str)} + {np(dat)}
zagrzać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zagrzać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
zagrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zagrzać: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(str,sg,'miejsce',natr)}
zagrzechotać: _: : perf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
zagrzechotać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zagrzechotać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zagrzewać się: _: : imperf: subj{np(str)} + {np(dat)}
zagrzewać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zagrzewać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
zagrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zagrzewać: _: : imperf: subj{np(str)} + {xp(locat)} + {lexnp(str,sg,'miejsce',natr)}
zagrzmieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zagrzmieć: _: : perf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
zagrzmieć: _: : perf: subj{E}
zagrzmieć: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zagrzmieć: _: : perf: subj{np(str)} + {cp(żeby)}
zagrzmieć: _: : perf: subj{np(str)} + {np(inst)}
zagrzmieć: _: : perf: subj{np(str)} + {or}
zagrzmieć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zagrzmieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zagrzmieć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
zagrzmieć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zagubić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zagubić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zagubić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zagwarantować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zagwarantować: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
zagwarantować: _: : perf: subj{np(str)} + {or}
zahaczać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zahaczać się: _: : imperf: subj{np(str)} + {xp(locat)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zahaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zahaczyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zahaczyć się: _: : perf: subj{np(str)} + {xp(locat)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zahaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zainaugurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zainfekować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zainicjować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zainkasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zainkasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
zainspirować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zainspirować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zainspirować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zainstalować się: _: : perf: subj{np(str)} + {xp(locat)}
zainstalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zainteresować się: _: : perf: subj{np(str)} + {cp(int)}
zainteresować się: _: : perf: subj{np(str)} + {np(inst); cp(że); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zainteresować: _: : perf: subj{cp(int)} + {np(str)}
zainteresować: _: : perf: subj{cp(że)} + {np(str)}
zainteresować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zainteresować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zaintrygować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaintrygować się: _: : perf: subj{np(str)} + {or}
zaintrygować: _: : perf: subj{cp(int)} + {np(str)}
zaintrygować: _: : perf: subj{cp(że)} + {np(str)}
zaintrygować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
zaintrygować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zainwestować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,żeby)}
zaistnieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaistnieć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {xp(temp)}
zaistnieć: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
zajadać się: _: : imperf: subj{np(str)} + {np(inst)}
zajadać: _: : imperf: subj{np(str)} + obj{np(str)}
zajarać się: _: : perf: subj{np(str)} + {cp(int)}
zajarać się: _: : perf: subj{np(str)} + {cp(że)}
zajarać się: _: : perf: subj{np(str)} + {np(dat)}
zajarać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zajarać się: _: : perf: subj{np(str)} + {or}
zajarać: _: : perf: subj{np(str)} + obj{np(str)}
zająć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
zająć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zająć: _: : perf: subj{np(str)} + obj{lexnp(str,_,'miejsce',atr)} + {prepnp(w,loc)}
zająć: _: : perf: subj{np(str)} + obj{lexnp(str,_,'pozycja',atr)} + {prepnp(w,loc)}
zająć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zająć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zająknąć się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zająknąć się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
zająknąć się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zająknąć się: _: : perf: subj{np(str)} + {cp(int)}
zająknąć się: _: : perf: subj{np(str)} + {cp(że)}
zająknąć się: _: : perf: subj{np(str)} + {or}
zająknąć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zajechać: _: : perf: {np(inst)} + {prepnp(na,acc)}
zajechać: _: : perf: {np(inst)} + {xp(abl)}
zajechać: _: : perf: {np(inst)} + {xp(locat)}
zajechać: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zajechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zajechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zajeździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zajeżdżać: _: : imperf: {np(inst)} + {prepnp(na,acc)}
zajeżdżać: _: : imperf: {np(inst)} + {xp(abl)}
zajeżdżać: _: : imperf: {np(inst)} + {xp(locat)}
zajeżdżać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zajeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zajęczeć: _: : perf: subj{np(str)} + {cp(że)}
zajęczeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
zajęczeć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
zajęczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zajęczeć: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {or}
zajęczeć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zajęczeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zajmować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
zajmować: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'miejsce',atr)} + {prepnp(w,loc)}
zajmować: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'pozycja',atr)} + {prepnp(w,loc)}
zajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zajrzeć: _: : perf: subj{np(str)} + {cp(int)}
zajrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
zajrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zajrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zajrzeć: _: : perf: subj{np(str)} + {xp(adl)}
zajść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zajść: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(za,acc,sg,'skóra',natr)}
zajść: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
zajść: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)}
zajść: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zajść: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zajść: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
zakazać: _: : perf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakazywać: _: : imperf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakąsić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakąszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaklasyfikować się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zaklasyfikować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zaklasyfikować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaklasyfikować się: _: : perf: subj{np(str)} + {xp(locat)}
zaklasyfikować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
zaklasyfikować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
zaklasyfikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zaklasyfikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zaklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaklasyfikować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaklasyfikować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zakląć się: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
zakląć się: _: : perf: subj{np(str)} + {or}
zakląć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zakląć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zakląć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zakląć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zakląć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zakląć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zakląć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zaklinać się: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
zaklinać się: _: : imperf: subj{np(str)} + {or}
zaklinać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zaklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zaklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zaklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zaklinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zakładać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
zakładać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zakładać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zakładać: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
zakładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zakładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zakładać: _: : imperf: subj{np(str)} + {or}
zakłócać się: _: : imperf: subj{np(str)} + {np(dat)}
zakłócać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
zakłócać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zakłócić się: _: : perf: subj{np(str)} + {np(dat)}
zakłócić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
zakłócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zakneblować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zakneblować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakochać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zakochiwać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zakodować się: _: : perf: {np(dat)} + {advp(pron)}
zakodować się: _: : perf: subj{cp(żeby)} + {np(dat)} + {xp(locat)}
zakodować się: _: : perf: subj{cp(że)} + {np(dat)} + {xp(locat)}
zakodować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zakodować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {xp(locat)}
zakodować: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {xp(locat)}
zakodować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {xp(locat)}
zakodować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {xp(locat)}
zakodować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zakołysać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zakołysać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zakołysać się: _: : perf: subj{np(str)} + {xp(locat)}
zakołysać: _: : perf: {np(inst)}
zakołysać: _: : perf: subj{np(str)} + {np(inst)}
zakołysać: _: : perf: subj{np(str)} + obj{np(str)}
zakomunikować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zakomunikować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zakomunikować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
zakomunikować: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zakontraktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zakontraktować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakończyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zakończyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zakończyć się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zakończyć się: _: : perf: subj{np(str)} + {xp(locat)}
zakończyć się: _: : perf: subj{np(str)} + {xp(temp)}
zakończyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zakończyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zakończyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zakończyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zakończyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakończyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zakorkować się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zakorkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakorzeniać się: _: : imperf: subj{cp(że)} + {prepnp(w,loc)}
zakorzeniać się: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(w,loc)}
zakorzeniać się: _: : imperf: subj{np(str)} + {xp(locat)}
zakorzeniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zakorzeniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zakorzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zakorzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakorzenić się: _: : perf: subj{cp(że)} + {prepnp(w,loc)}
zakorzenić się: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(w,loc)}
zakorzenić się: _: : perf: subj{np(str)} + {xp(locat)}
zakorzenić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zakorzenić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zakorzenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zakorzenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakosztować: _: : perf: subj{np(str)} + {cp(int)}
zakosztować: _: : perf: subj{np(str)} + {cp(że)}
zakosztować: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
zakotwiczyć się: _: : perf: subj{np(str)} + {xp(locat)}
zakotwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zakotwiczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakratować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakrawać: _: : imperf: subj{cp(int)} + {prepnp(na,acc)}
zakrawać: _: : imperf: subj{cp(że)} + {prepnp(na,acc)}
zakrawać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,acc)}
zakręcić się: _: : perf: {np(dat)} + {preplexnp(w,loc,sg,'głowa',atr)}
zakręcić się: _: : perf: subj{np(str)} + {or}
zakręcić się: _: : perf: subj{np(str)} + {prepnp(koło,gen)}
zakręcić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zakręcić się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
zakręcić się: _: : perf: subj{np(str)} + {xp(locat)}
zakręcić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
zakręcić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',atr)}
zakręcić: _: : perf: subj{np(str)} + {np(inst)}
zakręcić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zakręcić: _: : perf: subj{np(str)} + obj{np(str)}
zakrwawić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zakrwawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakryć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
zakryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
zakrywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
zakrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
zakrzyczeć się: _: : perf: subj{np(str)}
zakrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zakrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
zakrzyczeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zaksięgować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zaksięgować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zaksięgować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaksięgować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zaksięgować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaktualizować się: _: : perf: subj{np(str)}
zaktualizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaktywizować się: _: : perf: subj{np(str)} + {advp(misc)}
zaktywizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
zaktywizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zakupić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc)}
zakupić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(za,acc)} + {xp(locat)}
zakwalifikować się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zakwalifikować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zakwalifikować się: _: : perf: subj{np(str)} + {cp(żeby)}
zakwalifikować się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zakwalifikować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zakwalifikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zakwalifikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zakwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zakwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zakwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zakwaterować się: _: : perf: subj{np(str)} + {xp(locat)}
zakwaterować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakwestionować: _: : perf: subj{np(str)} + {cp(jakoby)}
zakwestionować: _: : perf: subj{np(str)} + obj{cp(int)}
zakwestionować: _: : perf: subj{np(str)} + obj{cp(że)}
zakwestionować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zakwitnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zakwitnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zalać się: _: : perf: subj{np(str)} + {np(inst)}
zalać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zalać: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'sadło',natr)} + {preplexnp(za,acc,sg,'skóra',natr)}
zalać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalec: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zalec: _: : perf: subj{np(str)} + {np(inst)}
zalec: _: : perf: subj{np(str)} + {np(str)}
zalec: _: : perf: subj{np(str)} + {prepnp(między,inst)}
zalec: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zalecać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zalecać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zalecać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zalecać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
zalecać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
zalecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zalecić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zalecić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zalecić: _: : perf: subj{np(str)} + {np(dat)} + {or}
zalecić: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
zalecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zalegać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
zalegać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
zalegać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
zalegać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zalegać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zalegać: _: : imperf: subj{np(str)} + {np(inst)}
zalegać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
zalegać: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
zalegać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
zalegać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(wobec,gen)} + {prepnp(z,inst)}
zalegać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zalegalizować się: _: : perf: subj{np(str)}
zalegalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zalepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalepić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zalepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalesiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalewać się: _: : imperf: subj{np(str)} + {np(inst)}
zalewać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zalewać: _: : imperf: subj{np(str)} + {cp(że)}
zalewać: _: : imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'sadło',natr)} + {preplexnp(za,acc,sg,'skóra',natr)}
zalewać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zalewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaleźć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(za,acc,sg,'skóra',natr)}
zaleźć: _: : perf: subj{np(str)} + {xp(adl)}
zależeć: _: : perf: subj{np(str)} + {np(str)}
zależeć: _: : imperf: {np(dat)} + {prepnp(na,loc); prepncp(na,loc,żeby)}
zależeć: _: : imperf: subj{cp(int)} + {prepnp(od,gen); prepncp(od,gen,int)}
zależeć: _: : imperf: subj{np(str); ncp(str,int)} + {prepnp(od,gen); prepncp(od,gen,int)}
zaliczać się: _: : imperf: subj{np(str); ncp(str,że)} + {prepnp(do,gen)}
zaliczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(na,acc,sg,'plus',natr)}
zaliczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(do,gen)}
zaliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'poczet',ratr)}
zaliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaliczać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaliczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(na,acc,sg,'plus',natr)}
zaliczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(do,gen)}
zaliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'poczet',ratr)}
zaliczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaliczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaludniać się: _: : imperf: subj{np(str)} + {np(inst)}
zaludniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaludnić się: _: : perf: subj{np(str)} + {np(inst)}
zaludnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
załadować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
załadować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
załadować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
załadowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
załadowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
załadowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
załagodzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
załagodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
załamać się: _: : perf: subj{np(str)} + {cp(int)}
załamać się: _: : perf: subj{np(str)} + {cp(że)}
załamać się: _: : perf: subj{np(str)} + {np(dat)}
załamać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
załamać się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
załamać: _: : perf: subj{cp(gdy)} + {np(str)}
załamać: _: : perf: subj{cp(int)} + {np(str)}
załamać: _: : perf: subj{cp(jak)} + {np(str)}
załamać: _: : perf: subj{cp(jeśli)} + {np(str)}
załamać: _: : perf: subj{cp(kiedy)} + {np(str)}
załamać: _: : perf: subj{cp(że)} + {np(str)}
załamać: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(str,pl,'ręka',natr)}
załamać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(str,pl,'ręka',natr)}
załamać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
załamać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
załamać: _: : perf: subj{np(str)} + obj{np(str)}
załamać: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {lexnp(str,pl,'ręka',natr)}
załamywać się: _: : imperf: subj{np(str)} + {cp(int)}
załamywać się: _: : imperf: subj{np(str)} + {cp(że)}
załamywać się: _: : imperf: subj{np(str)} + {np(dat)}
załamywać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
załamywać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
załamywać: _: : imperf: subj{cp(gdy)} + {np(str)}
załamywać: _: : imperf: subj{cp(int)} + {np(str)}
załamywać: _: : imperf: subj{cp(jak)} + {np(str)}
załamywać: _: : imperf: subj{cp(jeśli)} + {np(str)}
załamywać: _: : imperf: subj{cp(kiedy)} + {np(str)}
załamywać: _: : imperf: subj{cp(że)} + {np(str)}
załamywać: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(str,pl,'ręka',natr)}
załamywać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(str,pl,'ręka',natr)}
załamywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
załamywać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
załamywać: _: : imperf: subj{np(str)} + obj{np(str)}
załamywać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {lexnp(str,pl,'ręka',natr)}
załapać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
załapać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
załapać się: _: : perf: subj{np(str)} + {xp(adl)}
załapać się: _: : perf: subj{np(str)} + {xp(locat)}
załapać: _: : perf: subj{np(str)} + {cp(int)}
załapać: _: : perf: subj{np(str)} + {cp(że)}
załapać: _: : perf: subj{np(str)} + {cp(żeby)}
załapać: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
załapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
załapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
załapywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
załapywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
załapywać się: _: : imperf: subj{np(str)} + {xp(adl)}
załapywać się: _: : imperf: subj{np(str)} + {xp(locat)}
załapywać: _: : imperf: subj{np(str)} + {cp(int)}
załapywać: _: : imperf: subj{np(str)} + {cp(że)}
załapywać: _: : imperf: subj{np(str)} + {cp(żeby)}
załapywać: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
załapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
załapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
załatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
załatwiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
załatwiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
załatwiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
załatwiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
załatwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
załatwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
załatwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
załatwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
załatwić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
załatwić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
załatwić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
załatwić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
załatwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
załatwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
załatwić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
załatwić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
załazić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(za,acc,sg,'skóra',natr)}
załazić: _: : imperf: subj{np(str)} + {xp(adl)}
założyć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
założyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
założyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
założyć: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
założyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
założyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
założyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zamach: : : : {np(inst)} + {possp} + {prepnp(na,acc)}
zamach: : : : {possp} + {prepnp(na,acc)} + {lexnp(gen,sg,'stan',natr)}
zamach: : : : {possp} + {prepnp(przeciw,dat)}
zamach: : : : {possp} + {prepnp(przeciw,dat)} + {lexnp(gen,sg,'stan',natr)}
zamachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zamachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
zamachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zamachać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zamachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zamachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
zamachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
zamachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
zamachać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
zamachnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zamarzać: _: : imperf: subj{np(str)}
zamarznąć: _: : perf: subj{np(str)}
zamarzyć się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
zamarzyć się: _: : perf: subj{cp(żeby)} + {np(dat)}
zamarzyć się: _: : perf: subj{cp(że)} + {np(dat)}
zamarzyć się: _: : perf: subj{np(str)} + {np(dat)}
zamarzyć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zamarzyć: _: : perf: subj{np(str)} + {cp(że)}
zamarzyć: _: : perf: subj{np(str)} + {or}
zamarzyć: _: : perf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zamawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zamawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zamawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zamawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zamazać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamazywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zameldować się: _: : perf: subj{np(str)} + {np(dat)}
zameldować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zameldować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zameldować się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zameldować się: _: : perf: subj{np(str)} + {xp(locat)}
zameldować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zameldować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zameldować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zameldować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
zameldować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zameldować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zameldować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zameldować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zameldować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zameldować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
zamiatać: _: : imperf: {np(inst)}
zamiatać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zamiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zamieniać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zamieniać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zamieniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zamieniać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zamieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
zamieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zamieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zamieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zamieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zamienić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zamienić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zamienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zamienić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zamienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
zamienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zamienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zamienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zamienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zamierać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamierać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zamierać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zamierzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zamierzać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
zamierzać: _: : imperf: subj{np(str)} + {nonch}
zamierzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zamierzyć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zamierzyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zamieszać się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
zamieszać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zamieszać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
zamieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zamieszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamieszkać: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)}
zamieszkać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zamieszkiwać: _: : imperf: subj{np(str)} + obj{np(str)}
zamieszkiwać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)}
zamieszkiwać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zamieścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamieść: _: : perf: {np(inst)}
zamieść: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zamieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zamilknąć: _: : perf: subj{np(str)}
zaminować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamknąć się: _: : perf: subj{np(str)} + {np(dat)}
zamknąć się: _: : perf: subj{np(str)} + {np(inst)}
zamknąć się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
zamknąć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(w,loc)}
zamknąć się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zamknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
zamknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zamknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
zamknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zamknąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamknąć: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zamocować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
zamocować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zamocować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zamoczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zamoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zamoczyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zamontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamordować się: _: : perf: subj{np(str)} + {np(inst)}
zamordować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamortyzować się: _: : perf: subj{np(str)} + {np(dat)}
zamortyzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamówić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zamówić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zamówić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zamówić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zamrażać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zamrażać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zamrażać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zamrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zamrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zamrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zamrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zamrażać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zamrażać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
zamrozić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zamrozić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zamrozić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zamrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zamrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zamrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zamrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamrozić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zamrozić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zamrozić: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zamrugać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zamrugać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zamrzeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamrzeć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zamrzeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zamurować: _: : perf: {np(str)} + {prepnp(z,gen)}
zamurować: _: : perf: subj{cp(gdy)} + {np(str)}
zamurować: _: : perf: subj{cp(int)} + {np(str)}
zamurować: _: : perf: subj{cp(jak)} + {np(str)}
zamurować: _: : perf: subj{cp(jeśli)} + {np(str)}
zamurować: _: : perf: subj{cp(kiedy)} + {np(str)}
zamurować: _: : perf: subj{cp(że)} + {np(str)}
zamurować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zamurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamurować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zamurowywać: _: : imperf: {np(str)} + {prepnp(z,gen)}
zamurowywać: _: : imperf: subj{cp(gdy)} + {np(str)}
zamurowywać: _: : imperf: subj{cp(int)} + {np(str)}
zamurowywać: _: : imperf: subj{cp(jak)} + {np(str)}
zamurowywać: _: : imperf: subj{cp(jeśli)} + {np(str)}
zamurowywać: _: : imperf: subj{cp(kiedy)} + {np(str)}
zamurowywać: _: : imperf: subj{cp(że)} + {np(str)}
zamurowywać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zamurowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamurowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamurowywać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
zamustrować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)} + {refl}
zamustrować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,acc)} + {refl}
zamustrować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)} + {refl}
zamustrować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(locat)}
zamustrować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)}
zamustrować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,acc)}
zamustrować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)}
zamykać się: _: : imperf: subj{np(str)} + {np(dat)}
zamykać się: _: : imperf: subj{np(str)} + {np(inst)}
zamykać się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
zamykać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(w,loc)}
zamykać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
zamykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
zamykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zamykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
zamykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zamykać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamykać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
zamyślać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
zamyślać się: _: : imperf: subj{np(str)} + {cp(int)}
zamyślać się: _: : imperf: subj{np(str)} + {cp(że)}
zamyślać się: _: : imperf: subj{np(str)} + {or}
zamyślać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zamyślać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
zamyślać: _: : imperf: subj{np(str)} + {cp(że)}
zamyślać: _: : imperf: subj{np(str)} + obj{np(str)}
zamyślać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
zamyślić się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zamyślić się: _: : perf: subj{np(str)} + {cp(int)}
zamyślić się: _: : perf: subj{np(str)} + {cp(że)}
zamyślić się: _: : perf: subj{np(str)} + {or}
zamyślić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zamyślić: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zamyślić: _: : perf: subj{np(str)} + {cp(że)}
zamyślić: _: : perf: subj{np(str)} + obj{np(str)}
zamyślić: _: : perf: subj{np(str)} + {prepnp(o,loc)}
zanalizować: _: : perf: subj{np(str)} + obj{cp(int)}
zanalizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
zanegować: _: : perf: subj{np(str)} + obj{cp(że)}
zanegować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
zaniechać: _: : perf: subj{np(str)} + obj{np(gen)}
zaniedbać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaniedbać: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zaniedbać: _: : perf: subj{np(str)} + obj{np(gen)}
zaniedbać: _: : perf: subj{np(str)} + obj{np(str)}
zaniedbywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zaniedbywać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
zaniedbywać: _: : imperf: subj{np(str)} + obj{np(gen)}
zaniedbywać: _: : imperf: subj{np(str)} + obj{np(str)}
zaniemóc: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zaniemóc: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zaniemóc: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaniepokoić się: _: : perf: subj{np(str)} + {cp(int)}
zaniepokoić się: _: : perf: subj{np(str)} + {cp(że)}
zaniepokoić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaniepokoić się: _: : perf: subj{np(str)} + {or}
zaniepokoić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zaniepokoić: _: : perf: subj{cp(gdy)} + {np(str)}
zaniepokoić: _: : perf: subj{cp(jak)} + {np(str)}
zaniepokoić: _: : perf: subj{cp(jeśli)} + {np(str)}
zaniepokoić: _: : perf: subj{cp(kiedy)} + {np(str)}
zaniepokoić: _: : perf: subj{cp(że)} + {np(str)}
zaniepokoić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zaniepokoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zanieść się: _: : perf: {np(inst)} + {xp(abl)}
zanieść się: _: : perf: {prepnp(na,acc); prepncp(na,acc,że)}
zanieść się: _: : perf: subj{np(str)} + {np(inst)}
zanieść się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zanieść: _: : perf: {np(inst)} + {np(str)}
zanieść: _: : perf: {np(inst)} + {xp(abl)}
zanieść: _: : perf: {np(str)} + {xp(adl)}
zanieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
zanieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
zanieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zanikać: _: : imperf: subj{np(str)}
zaniknąć: _: : perf: subj{np(str)}
zaniżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zaniżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zanosić się: _: : imperf: {cp(że)}
zanosić się: _: : imperf: {cp(żeby2)}
zanosić się: _: : imperf: {np(inst)} + {xp(abl)}
zanosić się: _: : imperf: {prepncp(na,acc,żeby2)}
zanosić się: _: : imperf: {prepnp(na,acc); prepncp(na,acc,że)}
zanosić się: _: : imperf: subj{np(str)} + {np(inst)}
zanosić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
zanosić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zanosić: _: : imperf: {np(inst)} + {np(str)}
zanosić: _: : imperf: {np(inst)} + {xp(abl)}
zanosić: _: : imperf: {np(str)} + {xp(adl)}
zanosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
zanosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
zanosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zanotować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
zanotować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)} + {xp(locat)}
zanotować: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {xp(locat)}
zanotować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(inst)} + {xp(locat)}
zanotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zanucić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zanucić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
zanucić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
zanucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zanurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
zanurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
zanurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zanurzać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)} + {refl}
zanurzać: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)} + {refl}
zanurzać: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
zanurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
zanurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
zanurzyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zanurzyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)} + {refl}
zanurzyć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)} + {refl}
zanurzyć: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
zaobserwować: _: : perf: subj{np(str)} + {cp(int)}
zaobserwować: _: : perf: subj{np(str)} + {cp(jak)}
zaobserwować: _: : perf: subj{np(str)} + {cp(że)}
zaobserwować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zaoferować się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zaoferować się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zaoferować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zaoferować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zaoferować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zaokrąglać się: _: : imperf: subj{np(str)} + {np(dat)}
zaokrąglać się: _: : imperf: subj{np(str)} + {xp(locat)}
zaokrąglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zaokrąglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaokrąglać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaokrąglić się: _: : perf: subj{np(str)} + {np(dat)}
zaokrąglić się: _: : perf: subj{np(str)} + {xp(locat)}
zaokrąglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zaokrąglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaokrąglić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaokrętować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)} + {refl}
zaokrętować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,acc)} + {refl}
zaokrętować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)} + {refl}
zaokrętować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)}
zaokrętować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,acc)}
zaokrętować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)}
zaopatrywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zaopatrywać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(w,acc)}
zaopatrywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {xp(locat)}
zaopatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaopatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaopatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaopatrzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zaopatrzyć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(w,acc)}
zaopatrzyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {xp(locat)}
zaopatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaopatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaopatrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaopiekować się: _: : perf: subj{np(str)} + {np(inst)}
zaopiniować: _: : perf: subj{np(str)} + {cp(int)}
zaopiniować: _: : perf: subj{np(str)} + {cp(że)}
zaopiniować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zaopiniować: _: : perf: subj{np(str)} + {or}
zaordynować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaostrzać się: _: : imperf: subj{np(str)} + {np(dat)}
zaostrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaostrzyć się: _: : perf: subj{np(str)} + {np(dat)}
zaostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaoszczędzić: _: : perf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
zaoszczędzić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zaoszczędzić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
zaowocować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zapachnieć: _: : perf: controller{np(dat)} + controllee{infp(_)}
zapachnieć: _: : perf: controller{xp(locat)} + controllee{xp(mod)}
zapachnieć: _: : perf: {np(dat)} + {np(inst)} + {xp(abl)}
zapachnieć: _: : perf: {np(dat)} + {xp(abl)} + {xp(mod)}
zapachnieć: _: : perf: {np(inst)} + {xp(locat)}
zapachnieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zapachnieć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
zapachnieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapachnieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zapadać się: _: : imperf: subj{np(str)} + {preplexnp(pod,acc,sg,'ziemia',natr)}
zapadać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
zapadać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zapadać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zapadać: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'zdrowie',natr)}
zapadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zapadać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapadać: _: : imperf: subj{np(str)} + {xp(adl)}
zapadać: _: : imperf: subj{np(str)} + {xp(locat)}
zapakować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zapakować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zapakować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zapakować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapakować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapakować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zapakować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zapakować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapakować: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
zapalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
zapalać się: _: : imperf: subj{np(str)} + {np(inst)}
zapalać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zapalać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zapalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zapalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
zapalić się: _: : perf: subj{np(str)} + {np(inst)}
zapalić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zapalić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapalić: _: : perf: subj{np(str)} + {np(inst)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zapalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zapamiętać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapamiętać: _: : perf: subj{np(str)} + {cp(int)}
zapamiętać: _: : perf: subj{np(str)} + {cp(jak)}
zapamiętać: _: : perf: subj{np(str)} + {cp(że)}
zapamiętać: _: : perf: subj{np(str)} + {cp(żeby)}
zapamiętać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
zapamiętać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapamiętać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zapamiętać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby)}
zapamiętać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
zapamiętać: _: : perf: subj{np(str)} + {or}
zapanować: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
zapanować: _: : perf: subj{np(str)} + {xp(locat)}
zaparkować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaparkować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaparzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zaparzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
zaparzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaparzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaparzyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
zaparzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
zaparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapaść się: _: : perf: subj{np(str)} + {preplexnp(pod,acc,sg,'ziemia',natr)}
zapaść się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
zapaść się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zapaść się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapaść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zapaść: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'zdrowie',natr)}
zapaść: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zapaść: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapaść: _: : perf: subj{np(str)} + {xp(adl)}
zapaść: _: : perf: subj{np(str)} + {xp(locat)}
zapatrywać się: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {advp(misc)}
zapatrywać się: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {advp(misc)}
zapatrywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {advp(misc)}
zapatrywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zapatrywać się: _: : imperf: subj{np(str)} + {xp(adl)}
zapatrzyć się: _: : perf: subj{np(str)} + {cp(jak)}
zapatrzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,jak)}
zapatrzyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zapatrzyć się: _: : perf: subj{np(str)} + {xp(adl)}
zapełniać się: _: : imperf: subj{np(str)} + {np(inst)}
zapełniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapełnić się: _: : perf: subj{np(str)} + {np(inst)}
zapełnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaperzać się: _: : imperf: subj{np(str)} + {cp(że)}
zaperzać się: _: : imperf: subj{np(str)} + {np(dat)}
zaperzać się: _: : imperf: subj{np(str)} + {or}
zaperzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zaperzać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
zapewniać: _: : imperf: subj{np(str)} + obj{ncp(str,żeby)} + {np(dat)}
zapewniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zapewniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); cp(że); prepncp(o,loc,że)}
zapewnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zapewnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zapewnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zapewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
zapiąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zapiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapiąć: _: : perf: subj{np(str)} + {refl}
zapiec się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zapiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zapiekać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapiekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zapiekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zapisać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapisać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zapisać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zapisać: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(locat)}
zapisać: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(na,acc)}
zapisać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zapisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapisać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapisywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapisywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zapisywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zapisywać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(locat)}
zapisywać: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(na,acc)}
zapisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zapisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapiszczeć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zapiszczeć: _: : perf: {np(dat)} + {xp(locat)}
zapiszczeć: _: : perf: subj{np(str)} + {cp(że)}
zapiszczeć: _: : perf: subj{np(str)} + {cp(żeby)}
zapiszczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
zapiszczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapiszczeć: _: : perf: subj{np(str)} + {np(inst)}
zapiszczeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
zapiszczeć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
zaplanować: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zaplanować: _: : perf: subj{np(str)} + {cp(int)}
zaplanować: _: : perf: subj{np(str)} + {cp(żeby)}
zaplanować: _: : perf: subj{np(str)} + obj{cp(że)}
zaplanować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,acc)}
zaplanować: _: : perf: subj{np(str)} + {or}
zaplatać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaplatać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zaplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zaplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaplątać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaplątać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaplątać się: _: : perf: subj{np(str)} + {xp(locat)}
zaplątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zapleść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zapleść się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zapleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zapleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zapłacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
zapłacić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapłonąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapłonąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zapłonąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zapobiec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapobiec: _: : perf: subj{np(str)} + {np(inst)} + {ncp(dat,że)}
zapobiec: _: : perf: subj{np(str)} + {np(inst)} + {ncp(dat,żeby)}
zapobiegać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zapobiegać: _: : imperf: subj{np(str)} + {np(inst)} + {ncp(dat,że)}
zapobiegać: _: : imperf: subj{np(str)} + {np(inst)} + {ncp(dat,żeby)}
zapoczątkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapoczątkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapodziać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapodziać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapodziewać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapodziewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapolować: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zapominać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapominać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
zapominać: _: : imperf: subj{np(str)} + {np(gen)}
zapominać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
zapominać: _: : imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(jak); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zapomnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapomnąć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zapomnąć: _: : perf: subj{np(str)} + {np(gen)}
zapomnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
zapomnąć: _: : perf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(jak); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zapomnieć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapomnieć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zapomnieć: _: : perf: subj{np(str)} + {np(gen)}
zapomnieć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
zapomnieć: _: : perf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(jak); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zapowiadać się: _: : imperf: {prepncp(na,acc,żeby2)}
zapowiadać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiadać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zapowiadać się: _: : imperf: subj{cp(że)}
zapowiadać się: _: : imperf: subj{cp(żeby2)}
zapowiadać się: _: : imperf: subj{np(str)} + {advp(misc)}
zapowiadać się: _: : imperf: subj{np(str)} + {prepncp(na,acc,żeby2)}
zapowiadać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zapowiadać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
zapowiadać: _: : imperf: subj{np(str)} + {ncp(str,żeby2)}
zapowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
zapowiadać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiadać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zapowiadać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {np(dat)}
zapowiedzieć się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiedzieć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zapowiedzieć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
zapowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
zapowiedzieć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiedzieć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zapowiedzieć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {np(dat)}
zapoznać się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapoznać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapoznawać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapoznawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapragnąć: _: : perf: subj,controller{np(str)} + controllee{cp(żeby); infp(_)}
zapragnąć: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
zapraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zapraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zapraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {xp(adl)}
zapraszać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)} + {refl}
zaprawiać się: _: : imperf: subj{np(str)} + {np(inst)}
zaprawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zaprawiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zaprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zaprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zaprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaprawić się: _: : perf: subj{np(str)} + {np(inst)}
zaprawić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaprawić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zaprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zaprawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaprenumerować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaprenumerować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zaprenumerować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaprezentować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
zaprezentować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,loc)}
zaprezentować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
zaprezentować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zaprezentować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
zaprezentować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
zaprogramować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
zaprogramować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zaprogramować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaprogramować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaprogramować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zaprogramować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaprogramować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
zaprojektować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zaprojektować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zaprojektować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaproponować: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zaproponować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zaproponować: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
zaproponować: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
zaproponować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zaproponować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zaprosić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zaprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaprosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zaprosić: _: : perf: subj{np(str)} + {or}
zaprosić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)} + {refl}
zaprotestować: _: : perf: subj{np(str)} + {cp(że)}
zaprotestować: _: : perf: subj{np(str)} + {np(inst)}
zaprotestować: _: : perf: subj{np(str)} + {or}
zaprotestować: _: : perf: subj{np(str)} + {prepncp(przeciw,dat,żeby)}
zaprotestować: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że)}
zaprószyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaprószyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaprószyć: _: : perf: {np(dat)} + {np(inst)} + {np(str)}
zaprószyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaprzątać: _: : imperf: subj{cp(int)} + {np(dat)} + {np(str)}
zaprzątać: _: : imperf: subj{cp(żeby)} + {np(dat)} + {np(str)}
zaprzątać: _: : imperf: subj{cp(że)} + {np(dat)} + {np(str)}
zaprzątać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + obj{np(str)} + {np(dat)}
zaprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(int)}
zaprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
zaprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(żeby)}
zaprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zaprzątnąć: _: : perf: subj{cp(int)} + {np(dat)} + {np(str)}
zaprzątnąć: _: : perf: subj{cp(żeby)} + {np(dat)} + {np(str)}
zaprzątnąć: _: : perf: subj{cp(że)} + {np(dat)} + {np(str)}
zaprzątnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + obj{np(str)} + {np(dat)}
zaprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(int)}
zaprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
zaprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(żeby)}
zaprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zaprzeczać: _: : imperf: subj{np(str)} + {np(dat); cp(jakoby); cp(że); cp(żeby); ncp(dat,jakoby); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
zaprzeczać: _: : imperf: subj{np(str)} + {or}
zaprzeczyć: _: : perf: subj{np(str)} + {np(dat); cp(jakoby); cp(że); cp(żeby); ncp(dat,jakoby); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
zaprzeczyć: _: : perf: subj{np(str)} + {or}
zaprzestać: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)}
zaprzestać: _: : perf: subj{np(str)} + obj{np(gen)}
zaprzestawać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
zaprzestawać: _: : imperf: subj{np(str)} + obj{np(gen)}
zaprzyjaźniać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zaprzyjaźniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zaprzyjaźnić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zaprzyjaźnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zaprzysiąc się: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(na,acc)}
zaprzysiąc się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zaprzysiąc: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)} + {prepnp(na,acc)}
zaprzysiąc: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
zaprzysiąc: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zaprzysiąc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zaprzysiąc: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
zaprzysięgać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(na,acc)}
zaprzysięgać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zaprzysięgać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)} + {prepnp(na,acc)}
zaprzysięgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
zaprzysięgać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zaprzysięgać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zaprzysięgać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
zapuszczać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zapuszczać się: _: : imperf: subj{np(str)} + {xp(adl)}
zapuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zapuszczać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {lexnp(str,sg,'żuraw',natr)}
zapuszczać: _: : imperf: subj{np(str)} + {xp(locat)} + {lexnp(str,pl,'korzeń',natr)}
zapuścić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zapuścić się: _: : perf: subj{np(str)} + {xp(adl)}
zapuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zapuścić: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {lexnp(str,sg,'żuraw',natr)}
zapuścić: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(str,pl,'korzeń',natr)}
zapylać się: _: : imperf: subj{np(str)} + {np(dat)}
zapylać: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zapylać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zapylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapylić się: _: : perf: subj{np(str)} + {np(dat)}
zapylić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zapylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapytać się: _: : perf: subj{np(str)} + {np(gen)} + {cp(int)}
zapytać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
zapytać się: _: : perf: subj{np(str)} + {or}
zapytać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zapytać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zapytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zapytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zapytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {cp(int)}
zapytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
zapytywać się: _: : imperf: subj{np(str)} + {or}
zapytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
zapytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zapytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zarabiać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zarabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zarabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zarastać się: _: : imperf: subj{np(str)} + {np(dat)}
zarastać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zarastać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarazić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zarazić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
zarazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarażać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zarażać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
zarażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarchiwizować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zarchiwizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zareagować: _: : perf: subj{np(str)} + controller{prepnp(na,acc); prepncp(na,acc,gdy); prepncp(na,acc,jak); prepncp(na,acc,jakby); prepncp(na,acc,kiedy); prepncp(na,acc,że); prepncp(na,acc,żeby)} + controllee{xp(mod)}
zareagować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(na,acc)}
zareagować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zarechotać się: _: : perf: subj{np(str)}
zarechotać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zarechotać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zarechotać się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
zarechotać: _: : perf: subj{np(str)}
zarechotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zarechotać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zarechotać: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
zarejestrować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zarejestrować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zarejestrować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zarejestrować się: _: : perf: subj{np(str)} + {xp(locat)}
zarejestrować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zarejestrować: _: : perf: subj{np(str)} + obj{cp(int)}
zarejestrować: _: : perf: subj{np(str)} + obj{cp(jak)}
zarejestrować: _: : perf: subj{np(str)} + obj{cp(że)}
zarejestrować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
zarejestrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarejestrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zarejestrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zarejestrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zarejestrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zareklamować: _: : perf: subj{np(str)} + {cp(że)} + {refl}
zareklamować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
zareklamować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
zareklamować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zareklamować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zareklamować: _: : perf: subj{np(str)} + {or} + {refl}
zareklamować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zarekomendować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
zarekomendować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
zarekomendować: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zarekomendować: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zarekomendować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
zarekomendować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
zarekomendować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zarekomendować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zarekomendować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zarekomendować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zarekomendować: _: : perf: subj{np(str)} + {or}
zarekomendować: _: : perf: subj{np(str)} + {or} + {refl}
zarekwirować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarezerwować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarezerwować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zarezerwować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaręczać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zaręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zaręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
zaręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
zaręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {cp(że)}
zaręczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
zaręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zaręczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zaręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zaręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
zaręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
zaręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {cp(że)}
zaręczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
zaręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zarobić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zarobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zarobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zarobić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(po,loc)}
zarobić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
zaroić się: _: : perf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
zaroić się: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zaroić się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zaroić się: _: : perf: subj{np(str)} + {np(inst)}
zaroić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaroić się: _: : perf: subj{np(str)} + {xp(locat)}
zarosnąć się: _: : perf: subj{np(str)} + {np(dat)}
zarosnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zarosnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarumienić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zarumienić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zarumienić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zarumienić: _: : perf: subj{np(str)} + obj{np(str)}
zarwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zarwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zarwać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zarwać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zarwać: _: : perf: {np(str)} + {xp(locat)}
zarwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zarwać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zarwać: _: : perf: subj{np(str)} + {np(str)}
zarwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zarwać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zarysować się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
zarysować się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zarysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zarysowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
zarysowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zarysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zarywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zarywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zarywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zarywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zarywać: _: : imperf: {np(str)} + {xp(locat)}
zarywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zarywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zarywać: _: : imperf: subj{np(str)} + {np(str)}
zarywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zarywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zaryzykować: _: : perf: subj{np(str)} + {cp(że)}
zaryzykować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zaryzykować: _: : perf: subj{np(str)} + {np(str); ncp(str,że)}
zarząd: : : : {np(gen)} + {possp}
zarząd: : : : {np(inst)} + {possp}
zarząd: : : : {possp} + {prepnp(nad,inst)}
zarządzać: _: : imperf: subj{np(str)} + {advp(pron)}
zarządzać: _: : imperf: subj{np(str)} + {cp(że)}
zarządzać: _: : imperf: subj{np(str)} + {cp(żeby)}
zarządzać: _: : imperf: subj{np(str)} + obj{np(inst); ncp(inst,int)}
zarządzać: _: : imperf: subj{np(str)} + obj{np(str)}
zarządzać: _: : imperf: subj{np(str)} + {or}
zarządzić: _: : perf: subj{np(str)} + {advp(pron)}
zarządzić: _: : perf: subj{np(str)} + {cp(że)}
zarządzić: _: : perf: subj{np(str)} + {cp(żeby)}
zarządzić: _: : perf: subj{np(str)} + obj{np(inst); ncp(inst,int)}
zarządzić: _: : perf: subj{np(str)} + obj{np(str)}
zarządzić: _: : perf: subj{np(str)} + {or}
zarzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
zarzucać: _: : imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zarzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zarzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zarzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
zarzucić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
zarzucić: _: : perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zarzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zarzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zarzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
zarzynać się: _: : imperf: subj{np(str)} + {advp(misc)}
zarzynać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zarzynać się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
zarzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zarzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zarżnąć się: _: : perf: subj{np(str)} + {advp(misc)}
zarżnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zarżnąć się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
zarżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zarżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasada: : : : {np(gen); ncp(gen,int)} + {possp}
zasada: : : : {possp} + {comprepnp(na temat)}
zasada: : : : {possp} + {comprepnp(w kwestii)}
zasada: : : : {possp} + {comprepnp(w sprawie)}
zasada: : : : {possp} + {cp(że)}
zasada: : : : {possp} + {cp(żeby)}
zasada: : : : {possp} + {or}
zasada: : : : {possp} + {prepnp(co do,gen)}
zasada: : : : {possp} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zasadzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zasadzać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
zasadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
zasadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zasadzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zasadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zasalutować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zasalutować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zasądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zasądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zasądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zasądzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {comprepnp(na rzecz)}
zasądzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasądzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zasądzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zasądzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zasądzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {comprepnp(na rzecz)}
zaschnąć: _: : perf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
zaschnąć: _: : perf: {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
zaschnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaserwować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zasiać się: _: : perf: subj{np(str)} + {xp(locat)}
zasiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zasiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zasiadać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zasiadać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zasiadać: _: : imperf: subj{np(str)} + {xp(locat)}
zasiadywać się: _: : imperf: subj{np(str)} + {xp(locat)}
zasiadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zasiadywać: _: : imperf: subj{np(str)} + {xp(locat)}
zasiąść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zasiąść: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zasiąść: _: : perf: subj{np(str)} + {xp(locat)}
zasiedlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasiedlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasiedzieć się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zasiedzieć się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
zasiedzieć się: _: : perf: subj{np(str)} + {xp(locat)}
zasiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zasiewać się: _: : imperf: subj{np(str)} + {xp(locat)}
zasiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zasiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zasięgać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(od,gen)}
zasięgać: _: : imperf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
zasięgnąć: _: : perf: subj{np(str)} + obj{np(gen)} + {prepnp(od,gen)}
zasięgnąć: _: : perf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
zasilać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zasilać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasilać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zasilać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zasilić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zasilić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasilić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zasilić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zaskakiwać: _: : imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + obj{np(str)}
zaskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zaskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zaskarżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(z powodu)}
zaskarżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zaskarżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zaskarżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zaskarżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(z powodu)}
zaskarżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zaskarżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zaskarżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zasklepiać się: _: : imperf: subj{np(str)} + {np(inst)}
zasklepiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zasklepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasklepić się: _: : perf: subj{np(str)} + {np(inst)}
zasklepić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zasklepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaskoczyć: _: : perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + obj{np(str)}
zaskoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zaskoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaskoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaskoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zasłaniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
zasłaniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
zasłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
zasłaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
zasłonić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
zasłonić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
zasłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
zasłonić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
zasługa: : : : {possp} + {comprepnp(w kwestii)}
zasługa: : : : {possp} + {comprepnp(w sprawie)}
zasługa: : : : {possp} + {cp(że)}
zasługa: : : : {possp} + {preplexnp(na,loc,sg,'niwa',atr)}
zasługa: : : : {possp} + {prepnp(co do,gen)}
zasługa: : : : {possp} + {prepnp(dla,gen); prepnp(w,loc); xp(locat)}
zasługa: : : : {possp} + {prepnp(przed,inst)}
zasługa: : : : {possp} + {prepnp(wobec,gen)}
zasługa: : : : {possp} + {prepnp(względem,gen)}
zasługa: : : : {possp} + {prepnp(za,acc)}
zasługiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zasługiwać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(żeby)}
zasługiwać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zasłużyć się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zasłużyć się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(dla,gen)}
zasłużyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zasłużyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zasłużyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(dla,gen)}
zasłużyć się: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(w,loc)}
zasłużyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(żeby)}
zasłużyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zasłynąć: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zasłynąć: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zasłynąć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zasłynąć: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
zasłyszeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasłyszeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(od,gen)}
zasłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
zasłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(jak)}
zasłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(jakoby)}
zasłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
zasłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(żeby)}
zasłyszeć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {or}
zasmakować się: _: : perf: subj{np(str)} + {np(inst)}
zasmakować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zasmakować: _: : perf: subj{np(str)} + {np(dat)}
zasmakować: _: : perf: subj{np(str)} + {np(gen)}
zasmakować: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zasmucić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zasmucić się: _: : perf: subj{np(str)} + {cp(int)}
zasmucić się: _: : perf: subj{np(str)} + {cp(że)}
zasmucić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zasmucić się: _: : perf: subj{np(str)} + {or}
zasmucić: _: : perf: subj{cp(gdy)} + {np(str)}
zasmucić: _: : perf: subj{cp(int)} + {np(str)}
zasmucić: _: : perf: subj{cp(jak)} + {np(str)}
zasmucić: _: : perf: subj{cp(jeśli)} + {np(str)}
zasmucić: _: : perf: subj{cp(kiedy)} + {np(str)}
zasmucić: _: : perf: subj{cp(że)} + {np(str)}
zasmucić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zasmucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zasnąć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
zasnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zasnąć: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zasnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zasnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zasobny: : : : {preplexnp(z,gen,sg,'dom',natr)}
zasobny: : : : {prepnp(o,acc)}
zasobny: : : : {prepnp(w,acc)}
zaspać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zaspać: _: : perf: subj{np(str)} + {np(str)}
zaspać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaspać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zaspać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zaspakajać się: _: : imperf: subj{np(str)} + {np(inst)}
zaspakajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaspokajać się: _: : imperf: subj{np(str)} + {np(inst)}
zaspokajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaspokoić się: _: : perf: subj{np(str)} + {np(inst)}
zaspokoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zastać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zastać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zastanawiać się: _: : imperf: subj{np(str)} + {cp(że)}
zastanawiać się: _: : imperf: subj{np(str)} + {or}
zastanawiać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zastanawiać: _: : imperf: subj{cp(int)} + {np(str)}
zastanawiać: _: : imperf: subj{cp(że)} + {np(str)}
zastanawiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zastanowić się: _: : perf: subj{np(str)} + {cp(że)}
zastanowić się: _: : perf: subj{np(str)} + {or}
zastanowić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zastanowić: _: : perf: subj{cp(int)} + {np(str)}
zastanowić: _: : perf: subj{cp(że)} + {np(str)}
zastanowić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zastawać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zastawać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zastawiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
zastawiać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zastawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zastawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zastawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zastawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(locat)}
zastawić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zastawić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zastawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zastawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zastawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zastawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(locat)}
zastąpić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zastąpić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastąpić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastępować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zastępować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastępować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastosować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zastosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zastosować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zastraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zastraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zastraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zastraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zastraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zastrzec się: _: : perf: subj{np(str)} + {cp(że)}
zastrzec się: _: : perf: subj{np(str)} + {or}
zastrzec się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zastrzec: _: : perf: subj{np(str)} + obj{cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
zastrzec: _: : perf: subj{np(str)} + obj{cp(że)} + {lexnp(dat,_,'siebie',natr)}
zastrzec: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {lexnp(dat,_,'siebie',natr)}
zastrzec: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(dla,gen)}
zastrzec: _: : perf: subj{np(str)} + {or}
zastrzegać się: _: : imperf: subj{np(str)} + {cp(że)}
zastrzegać się: _: : imperf: subj{np(str)} + {or}
zastrzegać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
zastrzegać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
zastrzegać: _: : imperf: subj{np(str)} + obj{cp(że)} + {lexnp(dat,_,'siebie',natr)}
zastrzegać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {lexnp(dat,_,'siebie',natr)}
zastrzegać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(dla,gen)}
zastrzegać: _: : imperf: subj{np(str)} + {or}
zastrzelić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zastrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zastrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zastrzelić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
zastukać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zastukać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zastukać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zastukać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
zastukać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zastygać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zastygnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zasugerować się: _: : perf: subj{np(str)} + {cp(że)}
zasugerować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zasugerować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zasugerować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
zasugerować: _: : perf: subj{np(str)} + obj{cp(jakoby)} + {np(dat)} + {np(inst)}
zasugerować: _: : perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {np(inst)}
zasugerować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
zasugerować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
zaswędzieć: _: : perf: {np(str)} + {xp(locat)}
zaswędzieć: _: : perf: subj{cp(żeby)} + {np(str)}
zaswędzieć: _: : perf: subj{lexnp(str,sg,'ręka',natr)} + {np(str)} + {prepnp(na,acc)}
zaswędzieć: _: : perf: subj{np(str)} + {np(str)}
zaswędzieć: _: : perf: subj{np(str)} + {np(str)} + {cp(żeby)}
zasychać: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
zasychać: _: : imperf: {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
zasychać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zasyczeć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
zasyczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
zasyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zasyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zasyczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zasyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zasyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zasyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zasygnalizować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
zasygnalizować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
zasygnalizować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)}
zasygnalizować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
zasygnalizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
zasypać się: _: : perf: subj{np(str)} + {np(dat)}
zasypać: _: : perf: {np(dat)} + {np(inst)} + {np(str)}
zasypać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zasypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasypać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zasypać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zasypać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zasypiać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
zasypiać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zasypiać: _: : imperf: subj{np(str)} + obj{lexnp(str,pl,'gruszka',natr)} + {preplexnp(w,loc,sg,'popiół',natr)}
zasypiać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zasypiać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zasypiać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
zasypiać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zasypiać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zasypywać się: _: : imperf: subj{np(str)} + {np(dat)}
zasypywać: _: : imperf: {np(dat)} + {np(inst)} + {np(str)}
zasypywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zasypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zasypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zasypywać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
zaszantażować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zaszantażować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaszczepiać się: _: : imperf: subj{np(str)} + {np(inst)}
zaszczepiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zaszczepiać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
zaszczepiać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
zaszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zaszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zaszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaszczepić się: _: : perf: subj{np(str)} + {np(inst)}
zaszczepić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zaszczepić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaszczepić się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zaszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zaszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zaszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaszczuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaszczycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaszkodzić: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
zaszkodzić: _: : perf: subj{cp(gdy)} + {np(dat)}
zaszkodzić: _: : perf: subj{cp(jak)} + {np(dat)}
zaszkodzić: _: : perf: subj{cp(jeśli)} + {np(dat)}
zaszkodzić: _: : perf: subj{cp(kiedy)} + {np(dat)}
zaszkodzić: _: : perf: subj{cp(że)} + {np(dat)}
zaszkodzić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)}
zaszkodzić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zaszkodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zaszkodzić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
zaszokować: _: : perf: subj{cp(gdy)} + {np(str)}
zaszokować: _: : perf: subj{cp(int)} + {np(str)}
zaszokować: _: : perf: subj{cp(jak)} + {np(str)}
zaszokować: _: : perf: subj{cp(jeśli)} + {np(str)}
zaszokować: _: : perf: subj{cp(kiedy)} + {np(str)}
zaszokować: _: : perf: subj{cp(że)} + {np(str)}
zaszokować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zaszokować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że); ncp(str,int)}
zasztyletować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaszyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zaszyć się: _: : perf: subj{np(str)} + {xp(locat)}
zaszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
zaszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaszyfrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaścielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaślubić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaślubić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zaśmiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
zaśmiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
zaśmiecać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zaśmiecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaśmiecić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaśmiecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaśnieżyć się: _: : perf: subj{np(str)} + {np(dat)}
zaśnieżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaśpiewać: _: : perf: subj{np(str)} + {cp(że)}
zaśpiewać: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
zaśpiewać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaśpiewać: _: : perf: subj{np(str)} + {np(inst)} + {or}
zaśpiewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaświecać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zaświecać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
zaświecać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaświecać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
zaświecać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zaświecać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zaświecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaświecić się: _: : perf: subj{lexnp(str,pl,'oko',natr)} + {np(dat)} + {prepnp(do,gen)}
zaświecić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaświecić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
zaświecić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaświecić: _: : perf: subj{lexnp(str,pl,'oko',natr)} + {np(dat)} + {prepnp(do,gen)}
zaświecić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
zaświecić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zaświecić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zaświecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaświtać: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
zaświtać: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
zaświtać: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
zaświtać: _: : perf: subj{E}
zaświtać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zataczać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zataczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zataczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zataczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zataić: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
zataić: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
zataić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
zatajać: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
zatajać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
zatajać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
zataszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
zataszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
zatelefonować: _: : perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
zatelefonować: _: : perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
zatelefonować: _: : perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
zatelefonować: _: : perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
zatelefonować: _: : perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
zatęsknić się: _: : perf: {np(dat)} + {prepnp(do,gen)}
zatęsknić się: _: : perf: {np(dat)} + {prepnp(za,inst)}
zatęsknić się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zatęsknić: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zatęsknić: _: : perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,jak); prepncp(za,inst,że); prepncp(za,inst,żeby)}
zatlić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zatlić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatlić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zatlić się: _: : perf: {xp(locat)}
zatlić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatlić: _: : perf: subj{np(str)} + obj{np(str)}
zatłoczyć się: _: : perf: subj{np(str)} + {np(inst)}
zatłoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zatłuścić się: _: : perf: subj{np(str)} + {np(dat)}
zatłuścić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zatłuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatoczyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zatoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zatoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zatoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zatonąć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
zatracać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zatracać: _: : imperf: subj{np(str)} + obj{np(str)}
zatracić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zatracić: _: : perf: subj{np(str)} + obj{np(str)}
zatroszczyć się: _: : perf: subj{np(str)} + {cp(int)}
zatroszczyć się: _: : perf: subj{np(str)} + {cp(że)}
zatroszczyć się: _: : perf: subj{np(str)} + {cp(żeby)}
zatroszczyć się: _: : perf: subj{np(str)} + {np(inst)}
zatroszczyć się: _: : perf: subj{np(str)} + {or}
zatroszczyć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zatruć się: _: : perf: subj{np(str)} + {np(inst)}
zatruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatrudniać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudniać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatrudniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudniać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zatrudniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatrudniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatrudnić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudnić się: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatrudnić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudnić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zatrudnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatrudnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatruwać się: _: : imperf: subj{np(str)} + {np(inst)}
zatruwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatrzaskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatrzaskiwać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
zatrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
zatrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zatrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
zatrzaskiwać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
zatrzasnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatrzasnąć się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zatrzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
zatrzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zatrzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
zatrzasnąć: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zatrząść się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jak,str)}
zatrząść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepnp(z,gen)}
zatrząść się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'posada',natr)}
zatrząść: _: : perf: {np(inst)}
zatrząść: _: : perf: {np(str)}
zatrząść: _: : perf: subj{np(str)} + {np(inst)}
zatrzeć się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)}
zatrzeć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
zatrzeć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
zatrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,pl,'ręka',natr)}
zatrzymać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zatrzymać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zatrzymać się: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,int)}
zatrzymać się: _: : perf: subj{np(str)} + {xp(locat)}
zatrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zatrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zatrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zatrzymywać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zatrzymywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
zatrzymywać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,int)}
zatrzymywać się: _: : imperf: subj{np(str)} + {xp(locat)}
zatrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zatrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zatrzymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zatwierdzać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatwierdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatwierdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zatwierdzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zatwierdzić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatwierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatwierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zatwierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zatytułować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{or}
zatytułować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaufać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
zaufać: _: : perf: subj{np(str)} + {np(dat)} + {prepncp(w,acc,że)}
zaufać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaufanie: : : : {np(dat)} + {possp}
zaufanie: : : : {possp} + {prepnp(co do,gen); comprepnp(w kwestii); prepncp(co do,gen,że); preplexnp(pod,inst,sg,'wzgląd',atr)} + {prepnp(dla,gen); prepnp(do,gen); prepnp(między,inst); prepnp(wobec,gen); prepnp(względem,gen); prepnp(wśród,gen); comprepnp(w stosunku do); prepncp(względem,gen,że)}
zaufanie: : : : {possp} + {prepnp(do,gen)} + {cp(że)}
zaufanie: : : : {prepnp(do,gen); prepncp(do,gen,że)} + {prepnp(między,inst); prepnp(wśród,gen)}
zautomatyzować się: _: : perf: subj{np(str)}
zautomatyzować: _: : perf: subj{np(str)} + obj{np(str)}
zauważać: _: : imperf: subj{np(str)} + {cp(jak)}
zauważać: _: : imperf: subj{np(str)} + obj{cp(int); cp(że)}
zauważać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zauważać: _: : imperf: subj{np(str)} + {or}
zauważyć: _: : perf: subj{np(str)} + {cp(jak)}
zauważyć: _: : perf: subj{np(str)} + obj{cp(int); cp(że)}
zauważyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zauważyć: _: : perf: subj{np(str)} + {or}
zawadzać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
zawadzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zawadzić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zawadzić: neg: : perf: subj{cp(gdy)}
zawadzić: neg: : perf: subj{cp(jak)}
zawadzić: neg: : perf: subj{cp(jeśli)}
zawadzić: neg: : perf: subj{cp(kiedy)}
zawadzić: neg: : perf: subj{cp(że)}
zawadzić: neg: : perf: subj{cp(żeby2)}
zawadzić: neg: : perf: subj{infp(_)}
zawadzić: neg: : perf: subj{np(str)}
zawahać się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zawahać się: _: : perf: subj{np(str)} + {cp(int)}
zawahać się: _: : perf: subj{np(str)} + {cp(żeby)}
zawahać się: _: : perf: subj{np(str)} + {cp(żeby2)}
zawahać się: _: : perf: subj{np(str)} + {prepncp(nad,inst,żeby)}
zawahać się: _: : perf: subj{np(str)} + {prepncp(przed,inst,żeby2)}
zawahać się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
zawahać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zawahać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
zawalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zawalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zawalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zawarczeć: _: : perf: subj{np(str)} + {np(inst)}
zawarczeć: _: : perf: subj{np(str)} + {np(str)}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zawarczeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
zawdzięczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zawdzięczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że)}
zawetować: _: : perf: subj{np(str)} + obj{np(str)}
zawędrować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zawęzić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
zawęzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zawężać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
zawężać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zawiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
zawiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zawiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zawiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
zawiadamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zawiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
zawiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zawiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zawiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
zawiadomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zawiadywać: _: : imperf: subj{np(str)} + obj{np(inst)}
zawiązać się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
zawiązać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zawiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zawiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zawiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zawiązywać się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
zawiązywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zawiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zawiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zawiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zawierać się: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
zawierać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
zawierać: _: : imperf: subj{np(str)} + {np(str)}
zawierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawiesić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zawiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zawiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zawiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawiesić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zawieszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zawieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zawieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zawieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawieszać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zawijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
zawijać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zawijać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zawijać się: _: : imperf: subj{np(str)} + {xp(abl)}
zawijać się: _: : imperf: subj{np(str)} + {xp(locat)}
zawijać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zawijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zawijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zawijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zawijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawijać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zawijać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zawilgocić się: _: : perf: subj{np(str)} + {np(dat)}
zawilgocić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zawinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
zawinąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zawinąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zawinąć się: _: : perf: subj{np(str)} + {xp(abl)}
zawinąć się: _: : perf: subj{np(str)} + {xp(locat)}
zawinąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zawinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zawinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zawinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zawinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawinąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zawinąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zawinić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zawinić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
zawinić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
zawinić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
zawinić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
zawinić: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {nonch}
zawinić: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(w,loc)}
zawinić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {nonch}
zawinić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(wobec,gen)}
zawinić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(względem,gen)}
zawinić: _: : perf: subj{np(str)} + {prepnp(wobec,gen)} + {nonch}
zawinić: _: : perf: subj{np(str)} + {prepnp(względem,gen)} + {nonch}
zawinszować: _: : perf: subj{np(str)} + controller{lexnp(dat,sg,'siebie',natr)} + controllee{infp(_)}
zawinszować: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,sg,'siebie',natr)}
zawinszować: _: : perf: subj{np(str)} + {lexnp(dat,sg,'siebie',natr)} + {or}
zawinszować: _: : perf: subj{np(str)} + {np(part)} + {lexnp(dat,sg,'siebie',natr)}
zawisnąć: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zawisnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zawisnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(inst,sg,'wzrok',natr)}
zawisnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zawisnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zawisnąć: _: : perf: subj{np(str)} + {xp(locat)}
zawitać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zawitać: _: : perf: subj{np(str)} + {xp(abl)}
zawitać: _: : perf: subj{np(str)} + {xp(adl)}
zawitać: _: : perf: subj{np(str)} + {xp(locat)}
zawładnąć: _: : perf: subj{np(str)} + obj{np(inst)}
zawłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
zawłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
zawnioskować: _: : perf: subj{np(str)} + obj{np(str)}
zawnioskować: _: : perf: subj{np(str)} + {or}
zawnioskować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zawnioskować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
zawnioskować: _: : perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
zawodzić się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
zawodzić: _: : imperf: subj{np(str)} + {np(str)}
zawodzić: _: : imperf: subj{np(str)} + obj{np(str)}
zawodzić: _: : imperf: subj{np(str)} + {or}
zawołać: _: : perf: subj{np(str)} + {np(inst)} + {or}
zawołać: _: : perf: subj{np(str)} + obj{np(str)}
zawołać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zawołać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zawołać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zawołać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zawołać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zawołać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zawołać: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
zawracać się: _: : imperf: subj{np(str)} + {xp(adl)}
zawracać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)} + {np(str)}
zawracać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zawracać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zawrócić się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zawrócić się: _: : perf: subj{np(str)} + {xp(adl)}
zawrócić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zawrócić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zawrzeć się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
zawrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
zawrzeć: _: : perf: {comprepnp(na temat)} + {xp(locat)}
zawrzeć: _: : perf: {comprepnp(z powodu)} + {xp(locat)}
zawrzeć: _: : perf: {np(inst)} + {xp(locat)}
zawrzeć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zawrzeć: _: : perf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {xp(locat)}
zawrzeć: _: : perf: {prepnp(z,gen)} + {xp(locat)}
zawrzeć: _: : perf: subj{cp(że)} + {xp(locat)}
zawrzeć: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zawrzeć: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zawrzeć: _: : perf: subj{np(str)} + {cp(że)}
zawrzeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zawrzeć: _: : perf: subj{np(str)} + {np(inst)}
zawrzeć: _: : perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
zawrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zawrzeć: _: : perf: subj{np(str)} + {or}
zawrzeć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zawrzeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zawrzeć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zawrzeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zawrzeć: _: : perf: {xp(locat)} + {or}
zawstydzać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
zawstydzać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zawstydzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zawstydzać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {cp(że)}
zawstydzać: _: : imperf: subj{cp(gdy)} + {np(str)}
zawstydzać: _: : imperf: subj{cp(int)} + {np(str)}
zawstydzać: _: : imperf: subj{cp(jak)} + {np(str)}
zawstydzać: _: : imperf: subj{cp(jeśli)} + {np(str)}
zawstydzać: _: : imperf: subj{cp(kiedy)} + {np(str)}
zawstydzać: _: : imperf: subj{cp(że)} + {np(str)}
zawstydzać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zawstydzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zawstydzić się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
zawstydzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zawstydzić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zawstydzić się: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {cp(że)}
zawstydzić: _: : perf: subj{cp(gdy)} + {np(str)}
zawstydzić: _: : perf: subj{cp(int)} + {np(str)}
zawstydzić: _: : perf: subj{cp(jak)} + {np(str)}
zawstydzić: _: : perf: subj{cp(jeśli)} + {np(str)}
zawstydzić: _: : perf: subj{cp(kiedy)} + {np(str)}
zawstydzić: _: : perf: subj{cp(że)} + {np(str)}
zawstydzić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zawstydzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zawyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {or}
zawyć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
zawyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
zawyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
zawyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {or}
zawyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)} + {or}
zawyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {or}
zawyć: _: : perf: subj{or} + {np(dat)} + {xp(locat)}
zawyżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zawyżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zawyżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zawyżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zawyżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zawyżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zazdrościć: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że)}
zaziębiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaziębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaziębić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaziębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaznaczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zaznaczać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczać: _: : imperf: subj{np(str)} + {cp(int)}
zaznaczać: _: : imperf: subj{np(str)} + {cp(że)}
zaznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczać: _: : imperf: subj{np(str)} + {or}
zaznaczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zaznaczyć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczyć: _: : perf: subj{np(str)} + {cp(int)}
zaznaczyć: _: : perf: subj{np(str)} + {cp(że)}
zaznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczyć: _: : perf: subj{np(str)} + {or}
zaznajamiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zaznajamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zaznajomić się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zaznajomić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zażartować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zażartować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
zażartować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zażartować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zażądać: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)}
zażądać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(żeby)}
zażądać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {ncp(gen,żeby)}
zażegnać: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
zażegnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zażegnywać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
zażegnywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zażyczyć: _: : perf: subj{np(str)} + controller{lexnp(dat,_,'siebie',natr)} + controllee{infp(_)}
zażyczyć: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
zażyczyć: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {lexnp(dat,_,'siebie',natr)}
zażyczyć: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
zażyczyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
zażyć: _: : perf: subj{np(str)} + obj{np(gen)}
zażyć: _: : perf: subj{np(str)} + obj{np(part)}
zażyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zażyć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'mańka',natr)}
zażywać: _: : imperf: subj{np(str)} + {np(gen)}
zażywać: _: : imperf: subj{np(str)} + obj{np(part)}
zażywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(z,gen,sg,'mańka',natr)}
zbaczać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zbaczać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zbadać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zbadać się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zbadać się: _: : perf: subj{np(str)} + {xp(locat)}
zbadać: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
zbadać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
zbadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zbadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zbadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zbałamucić się: _: : perf: subj{np(str)}
zbałamucić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
zbałamucić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zbałamucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zbałamucić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zbankrutować: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zbawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zbawić: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('ode złego')}
zbawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zbezcześcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
zbić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zbić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'pantałyk',natr)}
zbić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'trop',natr)}
zbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {fixed('na kwaśne jabłko')}
zbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'miazga',atr)}
zbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
zbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zbiec się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'czas',natr)}
zbiec się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zbiec się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zbiec się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zbiec: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zbiec: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zbiegać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'czas',natr)}
zbiegać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zbiegać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zbiegać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zbiegać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zbiegać: _: : imperf: subj{np(str)} + {np(str)}
zbiegać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zbieleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zbieleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zbierać się: _: : imperf: {np(dat)} + {prepnp(na,acc)}
zbierać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
zbierać się: _: : imperf: subj{E} + {prepnp(na,acc)}
zbierać się: _: : imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,_,'siebie',natr)}
zbierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zbierać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zbierać się: _: : imperf: subj{np(str)} + {xp(abl)}
zbierać się: _: : imperf: subj{np(str)} + {xp(adl)}
zbierać się: _: : imperf: subj{np(str)} + {xp(locat)}
zbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
zbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zbierać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zbijać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zbijać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zbijać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'pantałyk',natr)}
zbijać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'trop',natr)}
zbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,acc,że)}
zbijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zbilansować się: _: : perf: subj{np(str)} + {np(inst)}
zbilansować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zbilansować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zbilansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zbilansować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zbilansować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zblednąć: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(przy,loc); prepncp(przy,loc,int); prepncp(przy,loc,że)}
zblednąć: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(wobec,gen); prepncp(wobec,gen,int); prepncp(wobec,gen,że)}
zblednąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zblednąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zblednąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zbliżać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zbliżać się: _: : imperf: subj{np(str)} + {xp(adl)}
zbliżać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen)}
zbliżać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zbliżyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zbliżyć się: _: : perf: subj{np(str)} + {xp(adl)}
zbliżyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen)}
zbliżyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zbłaźnić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
zbłaźnić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(wobec,gen)}
zbłaźnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
zbłaźnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
zboczyć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zboczyć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zbombardować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zbombardować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {xp(abl)}
zbombardować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zbrodnia: : : : {adjp(agr); prepnp(przeciw,dat); prepnp(z,inst); preplexnp(na,acc,sg,'szkoda',atr); preplexnp(na,loc,sg,'tło',atr); preplexnp(o,loc,sg,'charakter',atr)} + {possp}
zbrodnia: : : : {np(gen)} + {possp}
zbrodnia: : : : {possp} + {comprepnp(w stosunku do)}
zbrodnia: : : : {possp} + {prepnp(na,loc)}
zbrodnia: : : : {possp} + {prepnp(wobec,gen)}
zbroić: _: : perf: subj{np(str)} + {nonch}
zbroić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zbroić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zbroić: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zbrojny: : : : {np(inst)}
zbrojny: : : : {prepnp(w,acc)}
zbudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zbudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zbudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zbudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zbudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zbulwersować się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zbulwersować się: _: : perf: subj{np(str)} + {cp(int)}
zbulwersować się: _: : perf: subj{np(str)} + {cp(że)}
zbulwersować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zbulwersować się: _: : perf: subj{np(str)} + {or}
zbulwersować: _: : perf: subj{cp(gdy)} + {np(str)}
zbulwersować: _: : perf: subj{cp(int)} + {np(str)}
zbulwersować: _: : perf: subj{cp(jak)} + {np(str)}
zbulwersować: _: : perf: subj{cp(jeśli)} + {np(str)}
zbulwersować: _: : perf: subj{cp(kiedy)} + {np(str)}
zbulwersować: _: : perf: subj{cp(że)} + {np(str)}
zbulwersować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zbulwersować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zbuntować się: _: : perf: subj{np(str)} + {or}
zbuntować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zbuntować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {prepnp(w,loc)}
zbuntować się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
zbuntować się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
zbuntować: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {cp(żeby)}
zbuntować: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
zbuntować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
zburzyć się: _: : perf: subj{np(str)} + {np(dat)}
zburzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zbyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(dla,gen)}
zbyć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
zbyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
zbyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zbyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
zbyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zbyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zbyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zbywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(dla,gen)}
zbywać: _: : imperf: {np(dat)} + {np(gen)}
zbywać: _: : imperf: {prepnp(na,loc)} + {xp(locat)}
zbywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
zbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
zbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
zbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zbywać: neg: : imperf: {np(dat)} + {prepnp(na,loc)}
zdać się: _: : perf: subj,controller{cp(że)} + controllee{np(inst)} + {np(dat)}
zdać się: _: : perf: subj,controller{E} + controllee{infp(imperf)}
zdać się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
zdać się: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
zdać się: _: : perf: subj{cp(że)} + {np(dat)}
zdać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zdać: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'sprawa',natr)}
zdać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'sprawa',natr)}
zdać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zdać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zdać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zdać: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'sprawa',natr)}
zdarzać się: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)} + {xp(temp)}
zdarzać się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {xp(locat)}
zdarzać się: _: : imperf: subj{cp(żeby)} + {np(dat)} + {xp(temp)}
zdarzać się: _: : imperf: subj{cp(że)} + {np(dat)} + {xp(temp)}
zdarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zdarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
zdarzać: _: : imperf: subj{np(str)} + {cp(że)} + {xp(temp)}
zdarzyć się: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {xp(temp)}
zdarzyć się: _: : perf: subj{cp(żeby)} + {np(dat)} + {xp(locat)}
zdarzyć się: _: : perf: subj{cp(żeby)} + {np(dat)} + {xp(temp)}
zdarzyć się: _: : perf: subj{cp(że)} + {np(dat)} + {xp(temp)}
zdarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zdarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
zdarzyć: _: : perf: subj{np(str)} + {cp(że)} + {xp(temp)}
zdawać się: _: : imperf: subj,controller{cp(że)} + controllee{np(inst)} + {np(dat)}
zdawać się: _: : imperf: subj,controller{E} + controllee{infp(imperf)}
zdawać się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
zdawać się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
zdawać się: _: : imperf: subj{cp(że)} + {np(dat)}
zdawać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zdawać: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'sprawa',natr)}
zdawać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'sprawa',natr)}
zdawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zdawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zdawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zdawać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'sprawa',natr)}
zdążać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
zdążać: _: : imperf: subj{np(str)} + {cp(żeby)}
zdążać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zdążać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zdążać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
zdążać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
zdążać: _: : imperf: subj{np(str)} + {xp(adl)}
zdążyć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zdążyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zdążyć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zdążyć: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
zdechnąć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
zdechnąć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zdechnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',ratr)}
zdechnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zdechnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zdechnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdechnąć: _: : perf: subj{np(str)} + {prepnp(za,acc)}
zdecydować się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zdecydować się: _: : perf: subj{np(str)} + {cp(int)}
zdecydować się: _: : perf: subj{np(str)} + {cp(żeby)}
zdecydować się: _: : perf: subj{np(str)} + {or}
zdecydować się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zdecydować: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zdecydować: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zdecydować: _: : perf: subj{np(str)} + {cp(int)}
zdecydować: _: : perf: subj{np(str)} + {cp(że)}
zdecydować: _: : perf: subj{np(str)} + {cp(żeby)}
zdecydować: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zdecydować: _: : perf: subj{np(str)} + {or}
zdecydować: _: : perf: subj{np(str)} + {prepncp(o,loc,żeby)}
zdefiniować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zdefiniować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zdefiniować: _: : perf: subj{np(str)} + obj{cp(int)}
zdefiniować: _: : perf: subj{np(str)} + obj{cp(że)}
zdefiniować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zdefiniować: _: : perf: subj{np(str)} + {or}
zdeformować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zdeformować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdegenerować się: _: : perf: subj{np(str)}
zdegenerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdegradować się: _: : perf: subj{np(str)} + {advp(misc)}
zdegradować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zdegradować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
zdegradować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
zdegradować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zdegustować się: _: : perf: subj{np(str)}
zdegustować: _: : perf: subj{cp(że)} + obj{np(str)}
zdegustować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zdegustować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdejmować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zdejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdejmować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zdeklarować się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zdeklarować się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
zdeklarować się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zdeklarować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zdeklarować się: _: : perf: subj{np(str)} + {comprepnp(co do)}
zdeklarować się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zdeklarować się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
zdeklarować się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zdeklarować się: _: : perf: subj{np(str)} + {cp(int)}
zdeklarować się: _: : perf: subj{np(str)} + {cp(że)}
zdeklarować się: _: : perf: subj{np(str)} + {cp(żeby)}
zdeklarować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zdeklarować się: _: : perf: subj{np(str)} + {or}
zdeklarować się: _: : perf: subj{np(str)} + {preplexnp(po,loc,sg,'strona',ratr)}
zdeklarować się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zdeklarować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zdeklarować się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zdeklarować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)}
zdeklarować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zdeklarować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zdeklarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zdeklarować: _: : perf: subj{np(str)} + {or}
zdelegalizować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zdelegalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdementować: _: : perf: subj{np(str)} + {cp(jakoby)}
zdementować: _: : perf: subj{np(str)} + {cp(że)}
zdementować: _: : perf: subj{np(str)} + {cp(żeby)}
zdementować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,jakoby); ncp(str,że); ncp(str,żeby)}
zdementować: _: : perf: subj{np(str)} + {or}
zdemolować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdemontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdemontować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zdemoralizować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zdemoralizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zdenerwować się: _: : perf: subj{np(str)} + {cp(int)}
zdenerwować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdenerwować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
zdenerwować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zdenerwować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zdenerwować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zdenerwować się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zdenerwować: _: : perf: subj{cp(gdy)} + {np(str)}
zdenerwować: _: : perf: subj{cp(int)} + {np(str)}
zdenerwować: _: : perf: subj{cp(jak)} + {np(str)}
zdenerwować: _: : perf: subj{cp(kiedy)} + {np(str)}
zdenerwować: _: : perf: subj{cp(że)} + {np(str)}
zdenerwować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zdenerwować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdeponować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zderzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zderzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
zderzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zderzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zderzyć się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
zderzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zdestabilizować się: _: : perf: subj{np(str)}
zdestabilizować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
zdestabilizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdetonować się: _: : perf: subj{np(str)} + {np(inst)}
zdetonować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdetonować: _: : perf: subj{np(str)} + {refl}
zdewastować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdezelować się: _: : perf: subj{np(str)} + {np(dat)}
zdezelować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdezorientować się: _: : perf: subj{np(str)}
zdezorientować: _: : perf: subj{cp(gdy)} + {np(str)}
zdezorientować: _: : perf: subj{cp(int)} + {np(str)}
zdezorientować: _: : perf: subj{cp(jak)} + {np(str)}
zdezorientować: _: : perf: subj{cp(jeśli)} + {np(str)}
zdezorientować: _: : perf: subj{cp(kiedy)} + {np(str)}
zdezorientować: _: : perf: subj{cp(że)} + {np(str)}
zdezorientować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
zdezorientować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdiagnozować: _: : perf: subj{np(str)} + {cp(int)}
zdiagnozować: _: : perf: subj{np(str)} + {cp(że)}
zdiagnozować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(u,gen)}
zdiagnozować: _: : perf: subj{np(str)} + {or}
zdiagnozować: _: : perf: subj{np(str)} + {refl}
zdjąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zdjąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdjąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zdobić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zdobić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zdobny: : : : {np(inst)}
zdobny: : : : {prepnp(w,acc)}
zdobyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zdobyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zdobywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zdobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zdołać: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zdominować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdopingować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {cp(żeby)}
zdopingować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zdopingować: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zdopingować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zdopingować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zdopingować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zdopingować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zdradzać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zdradzać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zdradzać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdradzać się: _: : imperf: subj{np(str)} + {or}
zdradzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zdradzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {or}
zdradzać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
zdradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zdradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zdradzić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zdradzić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zdradzić się: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
zdradzić się: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
zdradzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
zdradzić się: _: : perf: subj{np(str)} + {or}
zdradzić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zdradzić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
zdradzić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zdradzić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {or}
zdradzić: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
zdradzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zdradzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zdrowieć: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
zdrowieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zdrożeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
zdrożeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc)} + {prepnp(z,gen)}
zdruzgotać: _: : perf: subj{cp(gdy)} + {np(str)}
zdruzgotać: _: : perf: subj{cp(int)} + {np(str)}
zdruzgotać: _: : perf: subj{cp(kiedy)} + {np(str)}
zdruzgotać: _: : perf: subj{cp(że)} + {np(str)}
zdruzgotać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zdruzgotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdumieć się: _: : perf: subj{np(str)} + {cp(int)}
zdumieć się: _: : perf: subj{np(str)} + {cp(że)}
zdumieć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdumieć się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zdumieć: _: : perf: subj{cp(gdy)} + {np(str)}
zdumieć: _: : perf: subj{cp(int)} + {np(str)}
zdumieć: _: : perf: subj{cp(jak)} + {np(str)}
zdumieć: _: : perf: subj{cp(kiedy)} + {np(str)}
zdumieć: _: : perf: subj{cp(że)} + {np(str)}
zdumieć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zdumieć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zdumiewać się: _: : imperf: subj{np(str)} + {cp(int)}
zdumiewać się: _: : imperf: subj{np(str)} + {cp(że)}
zdumiewać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdumiewać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zdumiewać: _: : imperf: subj{cp(gdy)} + {np(str)}
zdumiewać: _: : imperf: subj{cp(int)} + {np(str)}
zdumiewać: _: : imperf: subj{cp(jak)} + {np(str)}
zdumiewać: _: : imperf: subj{cp(kiedy)} + {np(str)}
zdumiewać: _: : imperf: subj{cp(że)} + {np(str)}
zdumiewać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zdumiewać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zdwoić się: _: : perf: subj{np(str)}
zdwoić: _: : perf: subj{np(str)} + obj{np(str)}
zdychać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
zdychać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zdychać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',ratr)}
zdychać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zdychać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zdychać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdychać: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
zdymisjonować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zdymisjonować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
zdynamizować się: _: : perf: subj{np(str)} + {np(dat)}
zdynamizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdyscyplinować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zdyscyplinować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zdyscyplinować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zdyscyplinować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zdyskwalifikować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
zdyskwalifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zdystansować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zdystansować się: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
zdystansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdystansować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
zdystansować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zdziałać: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
zdziałać: _: : perf: subj{np(str)} + obj{ncp(str,że)} + {np(inst)}
zdziałać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdziczeć: _: : perf: subj{np(str)}
zdzierać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
zdzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
zdziwić się: _: : perf: subj{np(str)} + {cp(int)}
zdziwić się: _: : perf: subj{np(str)} + {cp(że)}
zdziwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdziwić się: _: : perf: subj{np(str)} + {or}
zdziwić: _: : perf: subj{cp(int)} + {np(str)}
zdziwić: _: : perf: subj{cp(że)} + {np(str)}
zdziwić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zdziwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zebrać się: _: : perf: {np(dat)} + {prepnp(na,acc)}
zebrać się: _: : perf: subj{E} + {prepnp(na,acc)}
zebrać się: _: : perf: subj{np(str)} + {cp(żeby)}
zebrać się: _: : perf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,_,'siebie',natr)}
zebrać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zebrać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zebrać się: _: : perf: subj{np(str)} + {xp(abl)}
zebrać się: _: : perf: subj{np(str)} + {xp(adl)}
zebrać się: _: : perf: subj{np(str)} + {xp(locat)}
zebrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
zebrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zebrać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zechcieć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zechcieć: _: : perf: subj{np(str)} + {np(str)}
zedrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
zedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
zejść się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zejść się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zejść się: _: : perf: subj{np(str)} + {xp(adl)}
zejść się: _: : perf: subj{np(str)} + {xp(locat)}
zejść: _: : perf: {comprepnp(na temat)}
zejść: _: : perf: {np(dat)} + {prepnp(na,loc)}
zejść: _: : perf: {prepnp(na,acc)}
zejść: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zejść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zejść: _: : perf: subj{np(str)} + {np(str)}
zejść: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
zejść: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zejść: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zelektryzować się: _: : perf: subj{np(str)} + {np(inst)}
zelektryzować: _: : perf: subj{cp(int)} + {np(str)}
zelektryzować: _: : perf: subj{cp(że)} + {np(str)}
zelektryzować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zelektryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zelżyć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
zelżyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zelżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zelżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zelżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zelżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zemdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zemdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zemrzeć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
zemrzeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
zemrzeć: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
zemrzeć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
zemścić się: _: : perf: subj{ncp(str,że)} + {prepnp(na,loc)}
zemścić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)} + {prepnp(za,acc)}
zemścić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zepchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zepsuć się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zepsuć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zepsuć: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
zepsuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zerkać: _: : imperf: subj{np(str)} + {cp(int)}
zerkać: _: : imperf: subj{np(str)} + {cp(jak)}
zerkać: _: : imperf: subj{np(str)} + {cp(że)}
zerkać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zerkać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zerkać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
zerkać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zerkać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
zerkać: _: : imperf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int)}
zerkać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
zerknąć: _: : perf: subj{np(str)} + {cp(int)}
zerknąć: _: : perf: subj{np(str)} + {cp(jak)}
zerknąć: _: : perf: subj{np(str)} + {cp(że)}
zerknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zerknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zerknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
zerknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zerknąć: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
zerknąć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int)}
zerknąć: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
zeskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zeskanować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zeskanować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zeskanować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zeskanować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zeskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zesłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
zesłać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zespalać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zespalać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zespalać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zespalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zespalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zespolić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zespolić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zespolić się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zespolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zespolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zestawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zestawiać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {refl}
zestawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zestawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zestawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zestawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zestawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zestawić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
zestresować się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zestresować się: _: : perf: subj{np(str)} + {cp(int)}
zestresować się: _: : perf: subj{np(str)} + {cp(że)}
zestresować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zestresować się: _: : perf: subj{np(str)} + {or}
zestresować: _: : perf: subj{cp(gdy)} + {np(str)}
zestresować: _: : perf: subj{cp(int)} + {np(str)}
zestresować: _: : perf: subj{cp(jak)} + {np(str)}
zestresować: _: : perf: subj{cp(jeśli)} + {np(str)}
zestresować: _: : perf: subj{cp(kiedy)} + {np(str)}
zestresować: _: : perf: subj{cp(że)} + {np(str)}
zestresować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zestresować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zestrzelać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zestrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zestrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zestrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zestrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zestrzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zestrzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zestrzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zestrzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zestrzelić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zestrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zestrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zestrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zestrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zestrzeliwać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zestrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zestrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zestrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zestrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zesztywnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zesztywnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zesztywnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zesztywnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zesztywnieć: _: : perf: subj{np(str)} + {xp(locat)}
zetknąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby2)}
zetknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zetrzeć się: _: : perf: subj{np(str)} + {np(dat)}
zetrzeć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
zetrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'proch',atr)}
zetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pył',atr)}
zetrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
zewidencjonować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zeznać: _: : perf: subj{np(str)} + {np(dat)} + {advp(pron)}
zeznać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zeznać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zeznać: _: : perf: subj{np(str)} + {np(dat)} + {or}
zeznać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zeznać: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zeznawać: _: : imperf: subj{np(str)} + {np(dat)} + {advp(pron)}
zeznawać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
zeznawać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zeznawać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
zeznawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zeznawać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
zezwalać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zezwalać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zezwalać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zezwolić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zezwolić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zezwolić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zeżreć: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
zeżreć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zeżreć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zeżreć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zeżreć: _: : perf: subj{np(str)} + {refl}
zgadać się: _: : perf: {np(dat)} + {comprepnp(co do)}
zgadać się: _: : perf: {np(dat)} + {comprepnp(na temat)}
zgadać się: _: : perf: {np(dat)} + {cp(że)}
zgadać się: _: : perf: {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
zgadać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)} + {prepnp(z,inst)}
zgadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
zgadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zgadać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zgadnąć: _: : perf: subj{np(str)} + {cp(int)}
zgadnąć: _: : perf: subj{np(str)} + {cp(że)}
zgadnąć: _: : perf: subj{np(str)} + obj{np(str)}
zgadnąć: _: : perf: subj{np(str)} + {or}
zgadywać: _: : imperf: subj{np(str)} + {cp(int)}
zgadywać: _: : imperf: subj{np(str)} + {cp(że)}
zgadywać: _: : imperf: subj{np(str)} + obj{np(str)}
zgadywać: _: : imperf: subj{np(str)} + {or}
zgadzać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
zgadzać się: _: : imperf: subj{cp(że)}
zgadzać się: _: : imperf: subj{np(str)} + {cp(żeby)}
zgadzać się: _: : imperf: subj{np(str); ncp(str,że)}
zgadzać się: _: : imperf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że); prepncp(co do,gen,żeby)} + {prepnp(z,inst)}
zgadzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zgadzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)} + {prepnp(z,inst)}
zgadzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zgadzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
zganić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
zganić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zganić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zganić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zganić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zgarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zgarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zgarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zgarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zgasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zgasić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zgasić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'zarodek',natr)}
zgasnąć: _: : perf: subj{np(str)} + {np(dat)}
zgiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zgiąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zgiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zgiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgiąć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
zgiąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zgiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zginać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zginać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
zginać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zginać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zginąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,pl,'oko',natr)}
zginąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
zginąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zginąć: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zginąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zginąć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
zginąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zginąć: _: : perf: subj{np(str)} + {xp(locat)}
zgłaszać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zgłaszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl); xp(locat)}
zgłaszać się: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl); xp(locat)}
zgłaszać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
zgłaszać: _: : imperf: subj{np(str)} + {cp(że)} + {xp(locat)}
zgłaszać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zgłaszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zgłaszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {xp(locat)}
zgłaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zgłaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zgłębiać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
zgłębiać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
zgłębiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
zgłębić: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
zgłębić: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
zgłębić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
zgłosić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zgłosić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl); xp(locat)}
zgłosić się: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl); xp(locat)}
zgłosić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
zgłosić: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
zgłosić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zgłosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zgłosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {xp(locat)}
zgłosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zgłosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zgłupieć: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
zgłupieć: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
zgłupieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zgłupieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zgniatać się: _: : imperf: subj{np(str)} + {np(dat)}
zgniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zgniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zgnić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
zgnić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zgnić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zgnić: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zgnić: _: : perf: subj{np(str)} + {xp(locat)}
zgnieść się: _: : perf: subj{np(str)} + {np(dat)}
zgnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zgnieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zgodzić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zgodzić się: _: : perf: subj{np(str)} + {cp(żeby)}
zgodzić się: _: : perf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że); prepncp(co do,gen,żeby)} + {prepnp(z,inst)}
zgodzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zgodzić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zgodzić się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)} + {prepnp(z,inst)}
zgodzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zgodzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {or}
zgodzić się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
zgodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zgolić: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
zgolić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
zgolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
zgolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zgolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zgotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zgrać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zgrać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zgrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zgrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(od,gen)}
zgrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zgrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zgromadzić się: _: : perf: subj{np(str)} + {xp(locat)}
zgromadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgromić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zgromić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {or}
zgrzeszyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zgrzeszyć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zgrzeszyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zgrzytać: _: : imperf: subj{np(str)} + {lexnp(inst,pl,'ząb',natr)} + {or}
zgrzytać: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
zgrzytać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgrzytać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zgrzytać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)} + {lexnp(inst,pl,'ząb',natr)}
zgrzytać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(inst,pl,'ząb',natr)}
zgrzytnąć: _: : perf: subj{np(str)} + {lexnp(inst,pl,'ząb',natr)} + {or}
zgrzytnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgrzytnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zgrzytnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)} + {lexnp(inst,pl,'ząb',natr)}
zgrzytnąć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(inst,pl,'ząb',natr)}
zgubić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgubić się: _: : perf: subj{np(str)} + {np(inst)}
zgubić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zgubić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
zgubić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zgubić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'oko',natr)}
zgubić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgwałcić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zgwałcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zharmonizować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zharmonizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
ziać: _: : imperf: {np(inst)} + {prepnp(od,gen)}
ziać: _: : imperf: {np(inst)} + {xp(abl)}
ziać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
ziać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
ziać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
ziać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zidentyfikować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zidentyfikować się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
zidentyfikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zidentyfikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zidentyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zielenić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zielenić się: _: : imperf: subj{np(str)} + {np(inst)}
zielenić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
zielenić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zielenić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ziewać: _: : imperf: subj{np(str)}
ziewnąć: _: : perf: subj{np(str)}
zignorować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
zimować: _: : imperf: subj{np(str)} + {xp(locat)}
zindywidualizować się: _: : perf: subj{np(str)}
zindywidualizować: _: : perf: subj{np(str)} + obj{np(str)}
zintegrować się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
zintegrować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zintegrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zintegrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zintensyfikować się: _: : perf: subj{np(str)}
zintensyfikować: _: : perf: subj{np(str)} + obj{np(str)}
zinterpretować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(mod)}
zinwentaryzować: _: : perf: subj{np(str)} + obj{np(str)}
zionąć: _: : _: {np(dat)} + {np(inst)} + {xp(abl)}
zionąć: _: : _: subj{np(str)} + {np(dat)} + {xp(abl)}
zionąć: _: : _: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zionąć: _: : _: subj{np(str)} + {np(inst)} + {xp(abl)}
zionąć: _: : _: subj{np(str)} + {np(inst)} + {xp(adl)}
zionąć: _: : imperf: {np(inst)} + {xp(locat)}
zionąć: _: : imperf: subj{np(str)} + {np(inst)}
zipać: _: : imperf: subj{np(str)} + {fixed('ledwie')}
zipać: _: : imperf: subj{np(str)} + {fixed('ledwo')}
zipnąć: _: : perf: subj{np(str)}
zirytować się: _: : perf: subj{np(str)} + {cp(int)}
zirytować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zirytować się: _: : perf: subj{np(str)} + {or}
zirytować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zirytować: _: : perf: subj{cp(gdy)} + {np(str)}
zirytować: _: : perf: subj{cp(int)} + {np(str)}
zirytować: _: : perf: subj{cp(jak)} + {np(str)}
zirytować: _: : perf: subj{cp(jeśli)} + {np(str)}
zirytować: _: : perf: subj{cp(kiedy)} + {np(str)}
zirytować: _: : perf: subj{cp(że)} + {np(str)}
zirytować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zirytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ziścić się: _: : perf: subj{np(str)}
ziścić: _: : perf: subj{np(str)} + obj{np(str)}
zjadać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zjadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zjadać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(str,pl,'ząb',natr)}
zjawiać się: _: : imperf: subj{np(str)} + {xp(locat)}
zjawić się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zjawić się: _: : perf: subj{np(str)} + {xp(locat)}
zjawisko: : : : {cp(jakoby)}
zjawisko: : : : {cp(że)}
zjawisko: : : : {cp(żeby)}
zjawisko: : : : {np(gen); ncp(gen,int); ncp(gen,że)}
zjechać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zjechać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zjechać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zjechać się: _: : perf: subj{np(str)} + {xp(abl)}
zjechać się: _: : perf: subj{np(str)} + {xp(adl)}
zjechać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zjechać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zjechać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zjechać: _: : perf: subj{np(str)} + {xp(abl)}
zjechać: _: : perf: subj{np(str)} + {xp(adl)}
zjednać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zjednać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(dla,gen)}
zjednoczyć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
zjednoczyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zjednoczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zjednoczyć się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
zjednoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
zjednoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zjednoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zjednoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zjednywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zjednywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(dla,gen)}
zjeść: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
zjeść: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zjeść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zjeść: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(str,pl,'ząb',natr)}
zjeżdżać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zjeżdżać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zjeżdżać się: _: : imperf: subj{np(str)} + {xp(abl)}
zjeżdżać się: _: : imperf: subj{np(str)} + {xp(adl)}
zjeżdżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zjeżdżać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zjeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zjeżdżać: _: : imperf: subj{np(str)} + {xp(abl)}
zjeżdżać: _: : imperf: subj{np(str)} + {xp(adl)}
zjonizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
zlać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zlać się: _: : perf: subj{np(str)} + {np(inst)}
zlać: _: : perf: subj{np(str)} + {np(inst)} + {np(str); ncp(str,int); ncp(str,że)}
zlać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zlać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zlać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zlatywać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
zlatywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
zlatywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zlatywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlecać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zlecać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zlecać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
zlecać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zlecić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zlecić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zlecić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zlecić: _: : perf: subj{np(str)} + {np(dat)} + {or}
zlecić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zlecieć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
zlecieć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
zlecieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zlecieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlekceważyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zleniwieć: _: : perf: subj{np(str)}
zlepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(w,acc)}
zlepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zlepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(w,acc)}
zlepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zlewać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlewać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zlewać się: _: : imperf: subj{np(str)} + {np(inst)}
zlewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zlewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
zlewać: _: : imperf: subj{np(str)} + {np(inst)} + {np(str); ncp(str,int); ncp(str,że)}
zlewać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlewać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zlewać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zlewać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
zlęknąć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zlęknąć się: _: : perf: subj{np(str)} + {cp(int)}
zlęknąć się: _: : perf: subj{np(str)} + {cp(że)}
zlęknąć się: _: : perf: subj{np(str)} + {cp(żeby)}
zlęknąć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
zlęknąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zliczać: _: : imperf: subj{np(str)} + {cp(int)}
zliczać: _: : imperf: subj{np(str)} + {cp(że)}
zliczać: _: : imperf: subj{np(str)} + obj{np(str)}
zliczyć: _: : perf: subj{np(str)} + {cp(int)}
zliczyć: _: : perf: subj{np(str)} + {cp(że)}
zliczyć: _: : perf: subj{np(str)} + obj{np(str)}
zliczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zlikwidować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zlikwidować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zlitować się: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
zlitować się: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {or}
zlitować się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
zlokalizować się: _: : perf: subj{np(str)} + {xp(locat)}
zlokalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zlokalizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zlustrować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zlustrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zlustrować: _: : perf: subj{np(str)} + {refl}
złagodnieć: _: : perf: subj{np(str)} + {np(dat)}
złagodzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
złagodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
złamać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
złamać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
złamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
złamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
złapać się: _: : perf: subj{np(str)} + {np(gen)}
złapać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
złapać się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
złapać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
złapać się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
złapać: _: : perf: subj{np(str)} + {cp(int)}
złapać: _: : perf: subj{np(str)} + {cp(że)}
złapać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
złapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
złączyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
złączyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
złączyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
złączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
złączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
złączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
złocić się: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
złocić się: _: : imperf: subj{np(str)} + {np(dat)}
złocić się: _: : imperf: subj{np(str)} + {np(inst)}
złocić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
złocić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
złocić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
złorzeczyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
złorzeczyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
złorzeczyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
złorzeczyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
złorzeczyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
złorzeczyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
złorzeczyć: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
złościć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
złościć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
złościć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
złościć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
złościć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
złościć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
złościć: _: : imperf: subj{cp(gdy)} + {np(str)}
złościć: _: : imperf: subj{cp(jak)} + {np(str)}
złościć: _: : imperf: subj{cp(jeśli)} + {np(str)}
złościć: _: : imperf: subj{cp(kiedy)} + {np(str)}
złościć: _: : imperf: subj{cp(że)} + {np(str)}
złościć: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
złościć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
złożyć się: _: : perf: {np(dat)} + {cp(że)} + {advp(misc)}
złożyć się: _: : perf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
złożyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
złożyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
złożyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(po,acc)}
złożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
złożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
złożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
złożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
złożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
złożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zmagać się: _: : imperf: subj{np(str)} + {cp(żeby)}
zmagać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zmagać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
zmagać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmaleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmarnować się: _: : perf: subj{np(str)}
zmarnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zmarnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,_,'siebie',natr)}
zmarszczyć się: _: : perf: subj{np(str)} + {np(dat)}
zmarszczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
zmarszczyć się: _: : perf: subj{np(str)} + {xp(locat)}
zmarszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zmartwychwstać: _: : perf: subj{np(str)} + {np(inst)}
zmartwychwstać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,gen)}
zmartwychwstawać: _: : imperf: subj{np(str)} + {np(inst)}
zmartwychwstawać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,gen)}
zmarznąć: _: : perf: subj{np(str)} + {fixed('do szpiku kości')}
zmarznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zmarznąć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'kość',natr)}
zmarznąć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'sopel',natr)}
zmasakrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmasować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zmawiać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(z,inst)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zmawiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
zmawiać: _: : imperf: subj{np(str)} + obj{np(str)}
zmechanizować się: _: : perf: subj{np(str)}
zmechanizować: _: : perf: subj{np(str)} + obj{np(str)}
zmęczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zmęczyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
zmęczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zmiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zmiatać: _: : imperf: subj{np(str)} + {xp(abl)}
zmiażdżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmiąć się: _: : perf: subj{np(str)} + {np(dat)}
zmiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zmiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zmieniać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
zmieniać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zmieniać się: _: : imperf: subj{np(str)} + {np(dat)}
zmieniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zmieniać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zmieniać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zmieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
zmieniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zmieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zmieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zmienić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
zmienić się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zmienić się: _: : perf: subj{np(str)} + {np(dat)}
zmienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zmienić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zmienić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zmienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
zmienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
zmienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zmienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zmierzać: _: : imperf: subj{np(str)} + {prepncp(ku,dat,że)}
zmierzać: _: : imperf: subj{np(str)} + {prepncp(ku,dat,żeby)}
zmierzać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmierzać: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
zmierzać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zmierzchać się: _: : imperf: subj{E}
zmierzchać się: _: : imperf: subj{np(str)}
zmierzchać: _: : imperf: subj{E}
zmierzchać: _: : imperf: subj{np(str)} + {np(dat)}
zmierzchnąć się: _: : perf: subj{E}
zmierzchnąć się: _: : perf: subj{np(str)}
zmierzchnąć: _: : perf: subj{E}
zmierzchnąć: _: : perf: subj{np(str)} + {np(dat)}
zmierzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zmierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zmierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zmierzyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zmieszać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zmieszać się: _: : perf: subj{np(str)} + {np(inst)}
zmieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zmieścić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zmieścić się: _: : perf: subj{np(str)} + {xp(locat)}
zmieścić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
zmieścić: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
zmieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zmięknąć: _: : perf: subj{np(str)} + {np(dat)}
zmięknąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zmiksować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,loc)}
zmiksować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zmiksować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zmiksować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,loc)}
zmiksować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zmiksować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(z,inst)}
zmiksować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zmilczeć: _: : perf: subj{np(str)} + {cp(int)}
zmilczeć: _: : perf: subj{np(str)} + {cp(że)}
zmilczeć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zmilczeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zmilitaryzować: _: : perf: subj{np(str)} + obj{np(str)}
zmilitaryzować: _: : perf: subj{np(str)} + {refl}
zmiłować się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zminiaturyzować się: _: : perf: subj{np(str)}
zminiaturyzować: _: : perf: subj{np(str)} + obj{np(str)}
zminimalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zmniejszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmniejszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zmniejszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmniejszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zmobilizować się: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
zmobilizować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zmobilizować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zmobilizować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmobilizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zmobilizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmobilizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
zmoczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zmoczyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zmoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zmoczyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zmodernizować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zmodernizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmodyfikować się: _: : perf: subj{np(str)}
zmodyfikować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)} + {np(inst)}
zmodyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
zmodyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zmoknąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
zmoknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zmontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zmontować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zmotywować: _: : perf: subj{np(str)} + {cp(żeby)} + {refl}
zmotywować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zmotywować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
zmotywować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zmotywować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zmotywować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zmotywować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmotywować: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
zmóc się: _: : perf: subj{np(str)} + {cp(żeby)}
zmóc się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zmóc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmówić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(z,inst)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zmówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
zmówić: _: : perf: subj{np(str)} + obj{np(str)}
zmrozić się: _: : perf: subj{np(str)} + {np(dat)}
zmrozić: _: : perf: subj{cp(gdy)} + {np(str)}
zmrozić: _: : perf: subj{cp(int)} + {np(str)}
zmrozić: _: : perf: subj{cp(jak)} + {np(str)}
zmrozić: _: : perf: subj{cp(kiedy)} + {np(str)}
zmrozić: _: : perf: subj{cp(że)} + {np(str)}
zmrozić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zmrozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmusić: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zmusić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmusić: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zmusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zmusić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
zmusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zmusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmuszać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zmuszać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmuszać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zmuszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zmuszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
zmuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zmuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zmyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zmyć: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
zmyć: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'głowa',natr)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zmyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zmyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zmyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zmylić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
zmylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmyślać: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
zmyślać: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
zmyślać: _: : imperf: subj{np(str)} + {cp(int)}
zmyślać: _: : imperf: subj{np(str)} + {cp(że)}
zmyślać: _: : imperf: subj{np(str)} + obj{np(str)}
zmyślać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
zmyślać: _: : imperf: subj{np(str)} + {or}
zmyślać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zmyślić: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
zmyślić: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zmyślić: _: : perf: subj{np(str)} + {cp(int)}
zmyślić: _: : perf: subj{np(str)} + {cp(że)}
zmyślić: _: : perf: subj{np(str)} + obj{np(str)}
zmyślić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
zmyślić: _: : perf: subj{np(str)} + {or}
zmyślić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zmywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zmywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zmywać: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
zmywać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'głowa',natr)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
znacjonalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
znaczyć się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
znaczyć: _: : imperf: subj,controller{infp(_)} + controllee{infp(_)}
znaczyć: _: : imperf: subj{infp(_)} + {nonch}
znaczyć: _: : imperf: subj{np(str)} + {cp(że)}
znaczyć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(dla,gen)}
znaczyć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
znaczyć: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
znaczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
znaczyć: _: : imperf: subj{np(str)} + {or}
znać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
znać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
znać: _: : imperf: {np(str)} + {prepnp(po,loc)}
znać: _: : imperf: {prepnp(po,loc)} + {cp(że)}
znać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
znać: _: : imperf: subj{np(str)} + obj{cp(int)}
znać: _: : imperf: subj{np(str)} + obj{np(str)}
znać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(od,gen,sg,'podszewka',natr)}
znajdować się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
znajdować się: _: : imperf: subj{np(str)} + {prepnp(bez,gen)}
znajdować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
znajdować się: _: : imperf: subj{np(str)} + {xp(locat)}
znajdować: _: : imperf: subj{np(str)} + {cp(że)}
znajdować: _: : imperf: subj{np(str)} + {np(str)} + {advp(pron)}
znajdować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
znajdować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(str)}
znajdować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
znajdować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znajdować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
znakować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
znakować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
znaleźć się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
znaleźć się: _: : perf: subj{np(str)} + {prepnp(bez,gen)}
znaleźć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
znaleźć się: _: : perf: subj{np(str)} + {xp(locat)}
znaleźć: _: : perf: subj{np(str)} + {cp(że)}
znaleźć: _: : perf: subj{np(str)} + {np(str)} + {advp(pron)}
znaleźć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
znaleźć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(str)}
znaleźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
znaleźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znaleźć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
znamionować: _: : imperf: subj{np(str)} + {cp(że)}
znamionować: _: : imperf: subj{np(str); ncp(str,że)} + {np(str); ncp(str,że)}
znarowić się: _: : perf: subj{np(str)}
znarowić się: _: : perf: subj{np(str)} + {cp(że)}
znarowić się: _: : perf: subj{np(str)} + {np(dat)}
znarowić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
znarowić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
znarowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
znarowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zneutralizować się: _: : perf: subj{np(str)} + {xp(locat)}
zneutralizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zneutralizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
znęcać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
znęcić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
znęcić się: _: : perf: subj{np(str)} + {xp(adl)}
znęcić: _: : perf: subj{cp(że)} + {np(str)}
znęcić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen)}
znęcić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {xp(adl)}
znęcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
znęcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {xp(adl)}
zniechęcać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniecierpliwić się: _: : perf: subj{np(str)} + {cp(int)}
zniecierpliwić się: _: : perf: subj{np(str)} + {cp(że)}
zniecierpliwić się: _: : perf: subj{np(str)} + {cp(żeby)}
zniecierpliwić się: _: : perf: subj{np(str)} + {np(inst)}
zniecierpliwić się: _: : perf: subj{np(str)} + {or}
zniecierpliwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zniecierpliwić: _: : perf: subj{cp(że)} + {np(str)}
zniecierpliwić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
znieczulać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
znieczulać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
znieczulać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
znieczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
znieczulić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
znieczulić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
znieczulić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
znieczulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zniekształcać się: _: : imperf: subj{np(str)} + {np(dat)}
zniekształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zniekształcić się: _: : perf: subj{np(str)} + {np(dat)}
zniekształcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
znienawidzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
znienawidzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
znienawidzić: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
zniesławiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zniesławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zniesławić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zniesławić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
znieść: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(jak)}
znieść: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(że)}
znieść: _: : perf: subj,controller{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + controllee{xp(mod)}
znieść: _: : perf: subj{np(str)} + {cp(gdy)}
znieść: _: : perf: subj{np(str)} + {cp(jak)}
znieść: _: : perf: subj{np(str)} + {cp(kiedy)}
znieść: _: : perf: subj{np(str)} + {cp(że)}
znieść: _: : perf: subj{np(str)} + {np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
znieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
znieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
znikać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
znikać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zniknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
zniknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zniszczyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zniszczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zniszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zniweczyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
zniweczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zniwelować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zniżać się: _: : imperf: subj{np(str)} + {cp(żeby2)}
zniżać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby2)}
zniżać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
zniżać się: _: : imperf: subj{np(str)} + {xp(adl)}
zniżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zniżać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zniżać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zniżyć się: _: : perf: subj{np(str)} + {cp(żeby2)}
zniżyć się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby2)}
zniżyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zniżyć się: _: : perf: subj{np(str)} + {xp(adl)}
zniżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zniżyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zniżyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
znosić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
znosić: _: : perf: subj{np(str)} + obj{np(str)}
znosić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(jak)}
znosić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(że)}
znosić: _: : imperf: subj,controller{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + controllee{xp(mod)}
znosić: _: : imperf: subj{np(str)} + {np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
znosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
znosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
znosić: neg: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
znosić: neg: : imperf: subj{np(str)} + {cp(gdy)}
znosić: neg: : imperf: subj{np(str)} + {cp(jak)}
znosić: neg: : imperf: subj{np(str)} + {cp(kiedy)}
znosić: neg: : imperf: subj{np(str)} + {cp(że)}
znowelizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
znudzić się: _: : perf: subj,controllee{infp(imperf)} + controller{np(dat)}
znudzić się: _: : perf: subj{cp(że)} + {np(dat)}
znudzić się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)}
znudzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
znudzić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
znudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zobaczyć się: _: : perf: subj,controller{np(str)} + controllee{adjp(inst)}
zobaczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zobaczyć: _: : perf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)}
zobaczyć: _: : perf: subj{np(str)} + {cp(int)} + {preplexnp(na,acc,pl,'oko',batr)}
zobaczyć: _: : perf: subj{np(str)} + {cp(jak)} + {preplexnp(na,acc,pl,'oko',batr)}
zobaczyć: _: : perf: subj{np(str)} + {cp(żeby2)}
zobaczyć: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'oko',batr)}
zobaczyć: _: : perf: subj{np(str)} + {lexnp(inst,_,'oko',ratr)} + {refl}
zobaczyć: _: : perf: subj{np(str)} + {np(str); cp(int); cp(jak); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że)}
zobaczyć: _: : perf: subj{np(str)} + {np(str); ncp(str,że)} + {preplexnp(na,acc,pl,'oko',batr)}
zobaczyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
zobaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(inst,_,'oko',ratr)}
zobaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zobaczyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zobligować: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(w,loc)} + {refl}
zobligować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)} + {prepnp(w,loc)}
zobligować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zobligować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
zobligować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(że)}
zobligować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
zobligować: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)} + {refl}
zobligować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)} + {refl}
zobligować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)} + {refl}
zobojętnieć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zobojętnieć: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
zobojętnieć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zobowiązać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zobowiązać: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zobowiązać: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
zobowiązać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
zobowiązać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
zobowiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zobowiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zobowiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zobowiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
zobowiązać: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)} + {refl}
zobowiązać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)} + {refl}
zobowiązać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)} + {refl}
zobowiązywać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zobowiązywać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zobowiązywać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
zobowiązywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
zobowiązywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
zobowiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zobowiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zobowiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zobowiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
zobowiązywać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)} + {refl}
zobowiązywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)} + {refl}
zobowiązywać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)} + {refl}
zobrazować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
zobrazować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zobrazować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zorganizować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zorganizować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zorganizować się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
zorganizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zorganizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zorganizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zorganizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zorientować się: _: : perf: subj{np(str)} + {comprepnp(co do)}
zorientować się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zorientować się: _: : perf: subj{np(str)} + {cp(int)}
zorientować się: _: : perf: subj{np(str)} + {cp(że)}
zorientować się: _: : perf: subj{np(str)} + {or}
zorientować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zorientować się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
zorientować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
zorientować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zorientować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zorientować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zorientować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
zorientować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zostać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
zostać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zostać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zostać się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
zostać się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zostać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zostać: _: : perf: subj,controllee{infp(_)} + controller{np(dat)}
zostać: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
zostać: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
zostać: _: : perf: subj{ncp(str,że)} + {np(dat)}
zostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
zostać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
zostać: _: : perf: subj{np(str)} + {prepnp(bez,gen)}
zostać: _: : perf: subj{np(str)} + {prepnp(między,inst)}
zostać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zostać: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
zostać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zostać: _: : perf: subj{np(str)} + {xp(locat)}
zostawiać: _: : imperf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)} + {xp(locat)}
zostawiać: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
zostawiać: _: : imperf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',natr)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
zostawić: _: : perf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)} + {xp(locat)}
zostawić: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
zostawić: _: : perf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',natr)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zostawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
zrabować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zrabować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zranić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zranić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
zranić: _: : perf: subj{cp(gdy)} + {np(str)}
zranić: _: : perf: subj{cp(jak)} + {np(str)}
zranić: _: : perf: subj{cp(jeśli)} + {np(str)}
zranić: _: : perf: subj{cp(kiedy)} + {np(str)}
zranić: _: : perf: subj{cp(że)} + {np(str)}
zranić: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
zranić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zranić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,acc)}
zrastać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zrastać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zraszać się: _: : imperf: subj{np(str)} + {np(inst)}
zraszać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrazić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrazić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen)}
zrazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)}
zrazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrażać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrażać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen)}
zrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)}
zrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrealizować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zrealizować się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zrealizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zredagować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zredukować się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
zredukować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
zreferować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zreferować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zreferować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zreferować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zreformować się: _: : perf: subj{np(str)}
zreformować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zrefundować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zregenerować się: _: : perf: subj{np(str)} + {np(dat)}
zregenerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrehabilitować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zrehabilitować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zrehabilitować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
zrekompensować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(dat)}
zrekompensować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
zrekonstruować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrekonstruować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrekultywować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
zrelacjonować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zrelacjonować: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
zrelacjonować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zrelacjonować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zrelacjonować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
zrelaksować się: _: : perf: subj{np(str)} + {advp(misc)}
zrelaksować się: _: : perf: subj{np(str)} + {np(inst)}
zrelaksować: _: : perf: subj{np(str)} + {np(str)}
zremisować: _: : perf: subj{np(str)} + obj{np(str)}
zremisować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zreperować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zretuszować: _: : perf: subj{np(str)} + obj{np(str)}
zrewanżować się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zrewidować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zrewoltować się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zrewoltować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zrezygnować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
zrobić się: _: : perf: {np(dat)} + {xp(mod)}
zrobić się: _: : perf: subj,controller{np(str)} + controllee{adjp(pred)}
zrobić się: _: : perf: subj,controller{np(str)} + controllee{np(inst)}
zrobić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)}
zrobić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zrobić: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
zrobić: _: : perf: subj{np(str)} + {cp(że)} + {advp(misc)}
zrobić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {advp(misc)}
zrobić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
zrobić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
zrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zrobić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zrobić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {nonch} + {lexnp(dat,_,'siebie',natr)}
zrodzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zrodzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrosić się: _: : perf: subj{np(str)} + {np(inst)}
zrosić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zrosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrosnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zrosnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zrozumieć: _: : perf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
zrozumieć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zrozumieć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zrównać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
zrównać się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zrównać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
zrównać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
zrównać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zrównać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
zrównoważyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zrównoważyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrównoważyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zrównywać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
zrównywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zrównywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
zrównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
zrównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zrównywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
zróżnicować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zróżnicować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zróżnicować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
zróżnicować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zrujnować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zrujnować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
zrujnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zryczałtować: _: : perf: subj{np(str)} + obj{np(str)}
zrządzać: _: : imperf: subj{np(str)} + {advp(pron)}
zrządzać: _: : imperf: subj{np(str)} + {cp(że)}
zrządzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zrządzić: _: : perf: subj{np(str)} + {advp(pron)}
zrządzić: _: : perf: subj{np(str)} + {cp(że)}
zrządzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zrzec się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {comprepnp(na rzecz)}
zrzec się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
zrzednąć: _: : perf: subj{np(str)} + {np(dat)}
zrzekać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {comprepnp(na rzecz)}
zrzekać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
zrzeszać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zrzeszać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zrzeszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zrzeszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zrzucać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(po,acc)}
zrzucać się: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {cp(żeby)}
zrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zrzucić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(po,acc)}
zrzucić się: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {cp(żeby)}
zrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zsiadać się: _: : imperf: subj{np(str)}
zsiadać: _: : imperf: subj{np(str)} + {xp(abl)}
zsiąść się: _: : perf: subj{np(str)}
zsiąść: _: : perf: subj{np(str)} + {xp(abl)}
zstąpić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zstąpić: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zstępować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zstępować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsumować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zsumować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zsumować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zsumować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zsumować: _: : perf: subj{np(str)} + {cp(int)}
zsumować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zsunąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zsuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
zsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zszokować: _: : perf: subj{cp(gdy)} + {np(str)}
zszokować: _: : perf: subj{cp(int)} + {np(str)}
zszokować: _: : perf: subj{cp(jak)} + {np(str)}
zszokować: _: : perf: subj{cp(jeśli)} + {np(str)}
zszokować: _: : perf: subj{cp(kiedy)} + {np(str)}
zszokować: _: : perf: subj{cp(że)} + {np(str)}
zszokować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zszokować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że); ncp(str,int)}
zubażać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zubażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zubożać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zubożać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zubożyć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zubożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zutylizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zużyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zużyć się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zużyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zużyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zużyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zużywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
zużywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zużywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zużywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zużywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zwabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(adl)}
zwabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zwabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(adl)}
zwabić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zwać się: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
zwać się: _: : imperf: subj,controller{np(str)} + controllee{np(nom)}
zwać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
zwać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
zwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
zwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
zwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zwalać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
zwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zwalczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
zwalczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
zwalić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zwalić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zwalić się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
zwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zwalniać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
zwalniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zwalniać się: _: : imperf: subj{np(str)} + {xp(abl)}
zwalniać: _: : imperf: subj{np(str)} + {np(gen)}
zwalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zwalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwalniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zwaloryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwariować: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
zwariować: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
zwariować: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zwariować: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zwaśnić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zwaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zważać: _: : imperf: subj{np(str)} + {cp(int)}
zważać: _: : imperf: subj{np(str)} + {cp(że)}
zważać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zważyć: _: : perf: subj{np(str)} + {cp(int)}
zważyć: _: : perf: subj{np(str)} + {cp(że)}
zważyć: _: : perf: subj{np(str)} + obj{np(str)}
zważyć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zważyć: _: : perf: subj{np(str)} + {refl}
zwątpić: _: : perf: subj{np(str)} + {cp(int)}
zwątpić: _: : perf: subj{np(str)} + {cp(że)}
zwątpić: _: : perf: subj{np(str)} + {cp(żeby)}
zwątpić: _: : perf: subj{np(str)} + {or}
zwątpić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zwątpić: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
zwerbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwerbować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zwerbować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zwerbować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zweryfikować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zweryfikować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zweryfikować: _: : perf: subj{np(str)} + obj{cp(int)}
zweryfikować: _: : perf: subj{np(str)} + obj{cp(że)}
zweryfikować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zweryfikować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zwędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zwęglać się: _: : imperf: subj{np(str)} + {np(dat)}
zwęglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwęglić się: _: : perf: subj{np(str)} + {np(dat)}
zwęglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwęszyć: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
zwęszyć: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
zwęszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
zwęszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zwęzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwęzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwęzić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zwęzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zwężać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwężać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwężać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zwężać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zwiać: _: : perf: {np(dat)} + {np(str)} + {xp(abl)} + {xp(adl)}
zwiać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zwiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zwiać: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
zwiać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zwiastować: _: : _: subj{np(str)} + {np(dat)} + {cp(że)}
zwiastować: _: : _: subj{np(str)} + {np(dat)} + {cp(żeby2)}
zwiastować: _: : _: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
związać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
związać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {lexnp(str,sg,'koniec',natr)} + {preplexnp(z,inst,sg,'koniec',natr)}
związać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
związać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
związać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
związać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
związek: : : : {np(gen)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
związek: : : : {possp} + {prepnp(z,inst)}
związek: : : : {prepnp(między,inst)}
zwichnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
zwichrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
zwichrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zwiedzać: _: : imperf: subj{np(str)} + obj{np(str)}
zwiedzić: _: : perf: subj{np(str)} + obj{np(str)}
zwielokrotniać się: _: : imperf: subj{np(str)} + {np(inst)}
zwielokrotniać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
zwielokrotniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwielokrotniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwielokrotnić się: _: : perf: subj{np(str)} + {np(inst)}
zwielokrotnić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zwielokrotnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwielokrotnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwieńczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zwierzać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zwierzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zwierzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zwierzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
zwierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwierzchni: : : : {comprepnp(w stosunku do)}
zwierzchni: : : : {prepnp(dla,gen)}
zwierzchni: : : : {prepnp(nad,inst)}
zwierzchni: : : : {prepnp(wobec,gen)}
zwierzchni: : : : {prepnp(względem,gen)}
zwierzyć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zwierzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zwierzyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zwierzyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
zwierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwieść: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
zwieść: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zwieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zwieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
zwiewać: _: : imperf: {np(dat)} + {np(str)} + {xp(abl)} + {xp(adl)}
zwiewać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zwiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zwiewać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
zwiewać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zwiększać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwiększać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwiększyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwiększyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwijać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zwijać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zwijać się: _: : imperf: subj{np(str)} + {xp(abl)}
zwijać się: _: : imperf: subj{np(str)} + {xp(adl)}
zwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwilżać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zwilżać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zwilżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zwilżyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zwilżyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zwilżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zwinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwinąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zwinąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zwinąć się: _: : perf: subj{np(str)} + {xp(abl)}
zwinąć się: _: : perf: subj{np(str)} + {xp(adl)}
zwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwindować: _: : perf: subj{np(str)} + obj{np(str)}
zwisać: _: : imperf: subj{cp(int)} + {np(dat)} + {np(inst)}
zwisać: _: : imperf: subj{cp(że)} + {np(dat)} + {np(inst)}
zwisać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zwisać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zwisać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zwisać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zwlekać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zwlekać się: _: : imperf: subj{np(str)} + {xp(abl)}
zwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwlekać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)} + {xp(dur)}
zwodować: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {refl}
zwodować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
zwodować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zwodować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zwodzić: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
zwodzić: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
zwodzić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
zwodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zwojować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwolnić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zwolnić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zwolnić się: _: : perf: subj{np(str)} + {xp(abl)}
zwolnić: _: : perf: subj{np(str)} + {np(gen)}
zwolnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zwolnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwolnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zwołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zwołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zwołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zwołać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zwoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zwoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zwoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zwoływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zwracać się: _: : imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
zwracać się: _: : imperf: subj{np(str)} + {np(dat)}
zwracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
zwracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zwracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zwracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
zwracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepncp(z,inst,żeby)}
zwracać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zwracać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
zwracać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'uwaga',atr)}
zwracać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zwracać: _: : imperf: subj{np(str)} + obj{lexnp(str,sg,'uwaga',atr)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zwracać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwrócić się: _: : perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
zwrócić się: _: : perf: subj{np(str)} + {np(dat)}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepncp(z,inst,żeby)}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
zwrócić się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zwrócić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'uwaga',atr)}
zwrócić: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'uwaga',atr)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zwrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zwrócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zwrócić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwycięstwo: : : : {np(gen)} + {prepnp(nad,inst)}
zwycięstwo: : : : {possp} + {prepnp(nad,inst); prepnp(w,loc); prepnp(z,inst); xp(locat)}
zwycięstwo: : : : {possp} + {prepnp(przeciw,dat)}
zwycięstwo: : : : {possp} + {prepnp(wobec,gen)}
zwyciężać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwyciężać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zwyciężać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
zwyciężać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zwyciężyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwyciężyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zwyciężyć: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zwyciężyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zwyczaj: : : : {np(gen)} + {possp}
zwyczaj: : : : {possp} + {comprepnp(w kwestii)}
zwyczaj: : : : {possp} + {cp(że)}
zwyczaj: : : : {possp} + {cp(żeby)}
zwyczaj: : : : {possp} + {prepnp(co do,gen)}
zwyczaj: : : : {possp} + {xp(locat)}
zwyknąć: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zwyknąć: _: : perf: subj{np(str)} + {cp(żeby)}
zwymiotować: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
zwymiotować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwymiotować: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zwymiotować: _: : perf: subj{np(str)} + {prepnp(po,loc)}
zwymiotować: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zysk: : : : {adjp(agr)} + {possp} + {prepnp(od,gen); prepnp(z,gen); prepnp(za,acc); prepncp(z,gen,że); preplexnp(z,gen,sg,'tytuł',atr)} + {prepnp(za,acc)} + {preplexnp(w,loc,sg,'wysokość',atr)}
zysk: : : : {adjp(agr); prepnp(dla,gen)}
zysk: : : : {adjp(agr)} + {prepnp(dla,gen)} + {prepnp(od,gen); prepnp(z,gen); prepnp(za,acc); prepncp(z,gen,że); preplexnp(z,gen,sg,'tytuł',atr)} + {prepnp(za,acc)} + {preplexnp(w,loc,sg,'wysokość',atr)}
zyskać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zyskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zyskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zyskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zyskiwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zziajać się: _: : perf: subj{np(str)} + {np(inst)}
zziajać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zzuć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zzuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zżerać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
zżerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zżerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zżerać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zżerać: _: : imperf: subj{np(str)} + {refl}
zżółknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zżółknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zżuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zżyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zżymać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zżymać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
zżymać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
zżymać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zżymać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {or}
zżymać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zżymać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
żachnąć się: _: : perf: subj{np(str)} + {np(inst)}
żachnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
żachnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)} + {or}
żal: _: : imperf: controller{np(dat)} + controllee{infp(_)}
żal: _: : imperf: {np(dat)} + {cp(że)}
żal: _: : imperf: {np(dat)} + {np(gen); ncp(gen,że)}
żal: _: : imperf: {np(dat)} + {prepnp(za,acc)}
żal: _: : imperf: {np(dat)} + {prepnp(za,inst)}
żalić się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
żalić się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
żalić się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
żalić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
żalić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
żalić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
żalić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
żalić się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
żalić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
żalić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
żalić się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
żałosny: : : : {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
żałosny: : pred: : {cp(gdy)}
żałosny: : pred: : {cp(jak)}
żałosny: : pred: : {cp(jeśli)}
żałosny: : pred: : {cp(kiedy)}
żałosny: : pred: : {cp(że)}
żałosny: : pred: : {cp(żeby)}
żałować: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
żałować: _: : imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,że)}
żałować: _: : imperf: subj{np(str)} + {np(gen)} + {or}
żałować: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
żart: : : : {possp} + {comprepnp(na temat)} + {or}
żart: : : : {possp} + {comprepnp(w kwestii)}
żart: : : : {possp} + {comprepnp(w sprawie)}
żart: : : : {possp} + {comprepnp(w stosunku do)}
żart: : : : {possp} + {preplexnp(pod,inst,sg,'adres',atr)} + {or}
żart: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,że)}
żart: : : : {possp} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {cp(jakoby); cp(że)}
żart: : : : {possp} + {prepnp(o,loc)} + {or}
żart: : : : {possp} + {prepnp(wobec,gen)}
żart: : : : {possp} + {prepnp(wokół,gen)}
żart: : : : {possp} + {prepnp(względem,gen)}
żart: : : : {possp} + {prepnp(z,gen)} + {or}
żart: : : : {possp} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jakoby); prepncp(z,gen,że); prepncp(z,gen,żeby)} + {cp(jakoby); cp(że)}
żart: : : : {preplexnp(z,inst,sg,'broda',natr)}
żartować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
żartować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
żartować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
żartować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
żąć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
żądać: _: : imperf: subj{np(str)} + {np(gen); cp(żeby); ncp(gen,żeby)} + {prepnp(od,gen)}
żądać: _: : imperf: subj{np(str)} + {or}
żądanie: : : : {np(gen); prepnp(o,acc); ncp(gen,żeby)} + {possp} + {prepnp(od,gen)}
żądanie: : : : {possp} + {comprepnp(w stosunku do)}
żądanie: : : : {possp} + {cp(żeby)}
żądanie: : : : {possp} + {preplexnp(z,gen,sg,'tytuł',atr)}
żądanie: : : : {possp} + {prepnp(co do,gen); prepncp(co do,gen,żeby)}
żądanie: : : : {possp} + {prepnp(wobec,gen)}
żądanie: : : : {possp} + {prepnp(względem,gen)}
żebrać: _: : imperf: subj{np(str)} + {np(gen)} + {np(inst)}
żebrać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
żebrać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
żeglować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
żeglować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
żeglować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
żeglować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
żeglować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
żegnać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,inst)}
żegnać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
żenić się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
żenić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
żenić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
żerować: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
żerować: _: : imperf: subj{np(str)} + {xp(locat)}
żłobić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
żłobić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
żonaty: : : : {prepnp(z,inst)} + {xp(dur)}
żonglować: _: : imperf: subj{np(str)} + {np(inst)}
żółcić się: _: : imperf: subj{np(str)} + {np(inst)}
żółcić się: _: : imperf: subj{np(str)} + {xp(locat)}
żółcić: _: : imperf: subj{np(str)} + obj{np(str)}
żółcieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
żółcieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
żółcieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
żółcieć: _: : imperf: subj{np(str)} + {np(inst)}
żółknąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
żółknąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
żuć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
życzenie: : : : {np(gen); ncp(gen,żeby)} + {possp} + {prepnp(dla,gen)}
życzenie: : : : {np(gen); ncp(gen,żeby)} + {prepnp(dla,gen)} + {prepnp(od,gen)}
życzenie: : : : {possp} + {fixed('pobożne')}
życzenie: : : : {possp} + {prepnp(dla,gen)} + {cp(żeby)}
życzenie: : : : {prepnp(dla,gen)} + {prepnp(od,gen)} + {cp(żeby)}
życzliwy: : : : {comprepnp(w stosunku do)}
życzliwy: : : : {np(dat)}
życzliwy: : : : {prepnp(dla,gen)}
życzliwy: : : : {prepnp(wobec,gen)}
życzliwy: : : : {prepnp(względem,gen)}
życzyć: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
życzyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen); cp(żeby); ncp(gen,żeby); advp(misc)}
życzyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
życzyć: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
życzyć: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
żyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
żyć: _: : imperf: subj{np(str)} + {np(inst)}
żyć: _: : imperf: subj{np(str)} + {preplexnp(na,loc,pl,'walizka',natr)}
żyć: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
żyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
żyć: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
żyć: _: : imperf: subj{np(str)} + {xp(dur)}
żyć: _: : imperf: subj{np(str)} + {xp(locat)}
żyć: _: : imperf: subj{np(str)} + {xp(temp)}
żyrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
żyrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
żywić się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
żywić się: _: : imperf: subj{np(str)} + {np(inst)}
żywić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
żywić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
żywić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
żywić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
