
% 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: gotowe, 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)}
absolutyzować się: _: : imperf: subj{np(str)}
absolutyzować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
afiliować się: _: : _: subj{np(str)} + {prepnp(do,gen)}
afiliować się: _: : _: subj{np(str)} + {prepnp(przy,loc)}
afiliować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
afiliować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
afirmować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
afirmować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
afirmować: _: : imperf: subj{np(str)} + {cp(że)}
afirmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
afirmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
afirmować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
afirmować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
afiszować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
afiszować się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
afiszować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
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)}
agregować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
agregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {advp(misc)}
agregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
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)}
akumulować się: _: : imperf: subj{np(str)} + {xp(locat)}
akumulować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
alokować: _: : _: subj{np(str)} + obj{np(str)} + {advp(misc)}
alokować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
anarchizować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
ankietować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
anonimizować: _: : imperf: subj{np(str)} + obj{np(str)}
anonsować się: _: : _: subj{np(str)} + {or}
anonsować się: _: : _: subj{np(str)} + {xp(locat)}
anonsować: _: : _: subj{np(str)} + {np(dat)} + {cp(że)}
anonsować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)}
anonsować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
anonsować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
anonsować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
antagonizować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
antagonizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
antagonizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
antydatować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
antydatować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
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}
asekurować się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,gdy)}
asekurować się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
asekurować się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
asekurować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
asekurować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
asekurować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,gdy)}
asekurować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
asekurować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
asfaltować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
asymilować się: _: : _: subj{np(str)} + {prepnp(do,gen)}
asymilować się: _: : _: subj{np(str)} + {prepnp(z,inst)}
asymilować się: _: : _: subj{np(str)} + {xp(locat)}
asymilować się: _: : _: subj{np(str)} + {xp(mod)}
asymilować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
asymilować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
asymilować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
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}
atestować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
awizować się: _: : _: subj{np(str)} + {np(inst)} + {cp(że)}
awizować: _: : _: subj{np(str)} + {cp(że)}
awizować: _: : _: subj{np(str)} + obj{np(str)}
awizować: _: : _: subj{np(str)} + {xp(locat)} + {refl}
babrać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
babrać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
babrać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
babrać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
babrać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)} + {refl}
babrać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
babrać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
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)}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
bajać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
bajać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
bajdurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
bajerować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
bajerować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
bajerować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jakoby)}
bajerować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
bajerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
bajerować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
bajerować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,jakoby); prepncp(o,loc,że)} + {nonch}
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)}
balować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)}
balować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
balsamować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
balsamować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
bałaganić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
banalizować się: _: : imperf: subj{np(str)}
banalizować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
banalizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(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)}
barwić się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(mod)}
barwić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(mod)}
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)}
beczeć: _: : imperf: subj{np(str)} + {cp(że)}
beczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
bekać się: _: : imperf: {np(dat)} + {np(inst)}
bekać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
bekać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',natr)} + {or}
bekać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
bekać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
bekać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
bekać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
beknąć: _: : perf: subj{np(str)}
beknąć: _: : perf: subj{np(str)} + {or}
beknąć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
besztać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
besztać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
besztać: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
betonować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
betonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
betonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
betonować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
betonować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {refl}
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)}
biadać: _: : imperf: subj{np(str)} + {cp(int); cp(że)}
biadać: _: : imperf: subj{np(str)} + {or}
biadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
biadać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
biadolić: _: : imperf: subj{np(str)} + {cp(int)}
biadolić: _: : imperf: subj{np(str)} + {cp(że)}
biadolić: _: : imperf: subj{np(str)} + {cp(żeby)}
biadolić: _: : imperf: subj{np(str)} + {or}
biadolić: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
biadolić: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
biczować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
biczować: _: : imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
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)}
biednieć: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
biedować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {xp(locat)}
biedzić się: _: : imperf: subj{np(str)} + {cp(int)}
biedzić się: _: : imperf: subj{np(str)} + {cp(żeby)}
biedzić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
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)}
bielić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
bielić się: _: : imperf: subj{np(str)} + {np(inst)}
bielić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
bielić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
bielić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
bierny: : : : {comprepnp(w stosunku do)}
bierny: : : : {prepnp(wobec,gen)}
bierny: : : : {prepnp(względem,gen)}
bierzmować: _: : _: subj{np(str)} + obj{np(str)}
bierzmować: _: : _: subj{np(str)} + {refl}
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)}
bimbać: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
bimbać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
bimbać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(dat,_,'siebie',natr)}
bimbać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {lexnp(dat,_,'siebie',natr)}
bisować: _: : imperf: subj{np(str)} + {advp(misc)}
bisować: _: : imperf: subj{np(str)} + {np(str)}
bisować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
blagować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
blagować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
blagować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
blagować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
blagować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
blagować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)}
blagować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
blaknąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
blaknąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
blaknąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
blaknąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(mod)}
blaknąć: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
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)}
bluzgać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
bluzgać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
bluzgać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
bluzgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(od,gen)}
bluzgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
bluzgać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
bluzgać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
bluzgać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
bluzgać: _: : imperf: subj{np(str)} + {or}
bluzgać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
bluznąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
bluznąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
bluznąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
bluznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepadjp(od,gen)}
bluznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
bluznąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
bluznąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(przeciw,dat)}
bluznąć: _: : perf: subj{np(str)} + {or}
bluznąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
bluźnić: _: : imperf: subj{np(str)} + {cp(int)}
bluźnić: _: : imperf: subj{np(str)} + {cp(że)}
bluźnić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
bluźnić: _: : imperf: subj{np(str)} + {or}
bluźnić: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
bluźnić: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
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łaznować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
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łocić się: _: : imperf: subj{np(str)}
błocić się: _: : imperf: {xp(locat)}
błocić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
błocić: _: : imperf: subj{np(str)} + {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)}
bojkotować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
borować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
borować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
borować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
brązować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
brązowić się: _: : imperf: subj{np(str)} + {xp(locat)}
brązowić: _: : imperf: subj{np(str)} + obj{np(str)}
brązowieć: _: : imperf: subj{np(str)}
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)}
brodzić: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
brodzić: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)} + {xp(mod)}
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)}
bronować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
bronować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(mod)}
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)}
bruździć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
bruździć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
bruździć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
bruździć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
bruździć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
brykać: _: : imperf: subj{np(str)} + {np(inst)}
brykać: _: : imperf: subj{np(str)} + {xp(abl)}
brykać: _: : imperf: subj{np(str)} + {xp(adl)}
bryknąć: _: : perf: subj{np(str)} + {np(inst)}
bryknąć: _: : perf: subj{np(str)} + {xp(abl)}
bryknąć: _: : perf: subj{np(str)} + {xp(adl)}
brylować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(locat)}
brylować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
bryzgać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
bryzgać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
bryzgać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
bryznąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
bryznąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
bryznąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
brzdąkać: _: : imperf: subj{np(str)} + {np(inst)}
brzdąkać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
brzdąkać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
brzdąkać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {nonch}
brzdąkać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
brzdąkać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
brzdąknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
brzdąknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
brzdąknąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
brzdąknąć: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {nonch}
brzdąknąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
brzemienny: : : : {np(inst)}
brzemienny: : : : {prepnp(w,acc)}
brzemienny: : : : {prepnp(w,loc)}
brzęczeć: _: : imperf: {np(dat)} + {xp(dur)} + {xp(locat)}
brzęczeć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
brzęczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
brzęczeć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
brzękać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)} + {prepnp(na,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)}
brzydnąć: _: : imperf: subj{cp(int)} + {np(dat)}
brzydnąć: _: : imperf: subj{cp(że)} + {np(dat)}
brzydnąć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
buczeć: _: : imperf: subj{np(str)} + {cp(że)}
buczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
buczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
buczeć: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
buczeć: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {or}
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)}
budżetować: _: : imperf: subj{np(str)} + obj{np(str)}
buforować się: _: : imperf: subj{np(str)} + {advp(misc)}
buforować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
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)}
bulgotać: _: : imperf: {np(dat)} + {xp(locat)}
bulgotać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
bulgotać: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
butelkować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
byczyć się: _: : 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)}
bytować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
bytować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
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)}
bzyczeć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
bzyczeć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
bzykać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
bzykać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
bzykać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
bzykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
bzyknąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
bzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
bzyknąć: _: : perf: subj{np(str)} + {np(inst)}
bzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
bzyknąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
bzyknąć: _: : perf: subj{np(str)} + {xp(adl)}
cackać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
capnąć się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
capnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
capnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
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)}
cedować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
cedować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
cedować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {comprepnp(na rzecz)}
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)}
cembrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cementować się: _: : imperf: subj{np(str)} + {np(inst)}
cementować: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
cementować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
centrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
centrować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
chałturzyć: _: : imperf: subj{np(str)}
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)}
charczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
charczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
charczeć: _: : imperf: subj{np(str)} + {or}
charknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
charknąć: _: : perf: subj{np(str)} + {or}
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)}
chlasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
chlasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
chlasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
chlasnąć: _: : perf: subj{np(str)} + {np(inst)} + {or}
chlasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
chlasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
chlasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
chlasnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
chlasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chlasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
chlasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chlasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
chlasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
chlastać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
chlastać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
chlastać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
chlastać: _: : imperf: subj{np(str)} + {np(inst)} + {or}
chlastać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
chlastać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
chlastać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
chlastać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
chlastać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chlastać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
chlastać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chlastać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
chlastać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
chlipać: _: : imperf: subj{np(str)} + {cp(że)}
chlipać: _: : imperf: subj{np(str)} + {np(part)} + {xp(abl)}
chlipać: _: : imperf: subj{np(str)} + {or}
chlipać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
chlipać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
chlipnąć: _: : perf: subj{np(str)} + {cp(że)}
chlipnąć: _: : perf: subj{np(str)} + {np(part)} + {xp(abl)}
chlipnąć: _: : perf: subj{np(str)} + {or}
chlipnąć: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
chlipnąć: _: : perf: subj{np(str)} + {prepnp(za,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)}
chlupotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chlupotać: _: : imperf: subj{np(str)} + {np(inst)}
chlupotać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
chlupotać: _: : imperf: subj{np(str)} + {xp(perl)}
chlusnąć: _: : perf: {np(inst)} + {xp(abl)} + {xp(adl)}
chlusnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
chlusnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
chlusnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
chlusnąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
chlusnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
chlustać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
chlustać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
chlustać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
chlustać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
chlustać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
chlustać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
chłeptać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
chłodzić się: _: : imperf: subj{np(str)} + {xp(locat)}
chłodzić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
chłodzić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(za,inst,sg,'pomoc',natr)} + {refl}
chłodzić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)} + {refl}
chłodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
chłodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(za,inst,sg,'pomoc',natr)}
chłodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
chmurzyć się: _: : imperf: subj{np(str)} + {np(dat)}
chmurzyć się: _: : imperf: {xp(locat)}
chmurzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
chomikować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)} + {xp(locat)}
chomikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
chomikować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
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)}
chrapnąć: _: : perf: subj{np(str)}
chrobotać: _: : imperf: {prepnp(o,acc)}
chrobotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chrobotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
chrobotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
chrobotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
chrobotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chrobotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
chrobotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
chrobotać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
chrobotać: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
chrobotać: _: : imperf: subj{np(str)} + {xp(mod)}
chrobotać: _: : imperf: {xp(locat)}
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)}
chrypieć: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
chrypieć: _: : imperf: subj{np(str)} + {np(dat)}
chrypieć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)} + {xp(mod)} + {or}
chrypieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
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)}
chrząkać: _: : imperf: subj{np(str)} + {advp(misc)} + {or}
chrząkać: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'znak',ratr)}
chrząkać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
chrząkać: _: : imperf: subj{np(str)} + {xp(mod)}
chrząknąć: _: : perf: subj{np(str)} + {advp(misc)} + {or}
chrząknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
chrząknąć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'znak',ratr)}
chrząknąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
chrząknąć: _: : perf: subj{np(str)} + {xp(mod)}
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)}
chuliganić się: _: : imperf: subj{np(str)} + {xp(locat)}
chuliganić: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
chwiać się: _: : imperf: subj{np(str)} + {np(dat)}
chwiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
chwiać się: _: : imperf: subj{np(str)} + {xp(locat)}
chwiać: _: : imperf: subj{np(str)} + {np(inst)}
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)}
chybotać się: _: : imperf: subj{np(str)}
chybotać: _: : imperf: subj{np(str)} + {np(inst)}
chycić się: _: : perf: subj{np(str)} + {np(gen)}
chycić się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'lep',natr)}
chycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
chycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
chycić: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
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)}
ciachnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
ciachnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
ciachnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
ciachnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
ciamkać: _: : imperf: subj{np(str)}
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)}
cielić się: _: : imperf: subj{np(str)}
ciemiężyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ciemnieć: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
ciemnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
ciemnieć: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
ciemnieć: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(mod)} + {xp(temp)}
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)}
ciurkać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ciurkać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ciurkać: _: : imperf: subj{np(str)} + {xp(locat)}
clić: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
clić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
cudzołożyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
cukrować się: _: : imperf: subj{np(str)}
cukrować: _: : imperf: subj{np(str)} + {np(dat)}
cukrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cukrzyć: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
cyganić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
cyganić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
cykać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
cykać się: _: : imperf: subj{np(str)} + {cp(int)}
cykać się: _: : imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
cykać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
cykać: _: : imperf: subj{np(str)}
cykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
cyklinować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cynować: _: : imperf: subj{np(str)} + obj{np(str)}
cyrkulować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
cyrkulować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
cyrkulować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
czernieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
czernieć: _: : imperf: subj{np(str)} + {xp(mod)}
czernieć: _: : imperf: subj{np(str)} + {xp(temp)}
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)}
czerwienieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
czerwienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
czerwienieć: _: : imperf: subj{np(str)} + {xp(temp)}
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)}
czkać się: _: : imperf: {np(dat)} + {np(inst)}
czkać się: _: : imperf: subj{np(str)} + {np(inst)}
czkać: _: : imperf: subj{np(str)} + {advp(misc)} + {or}
czkać: _: : imperf: subj{np(str)} + {cp(że)}
czkać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
czkać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
czknąć się: _: : perf: {np(dat)} + {np(inst)}
czknąć się: _: : perf: {prepnp(w,loc)} + {or}
czknąć się: _: : perf: subj{np(str)} + {np(inst)}
czknąć: _: : perf: subj{np(str)} + {advp(misc)} + {or}
czknąć: _: : perf: subj{np(str)} + {cp(że)}
czknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
czknąć: _: : perf: subj{np(str)} + {prepnp(o,loc)}
człapać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
człapać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
człapać się: _: : imperf: subj{np(str)} + {xp(adl)}
człapać się: _: : imperf: subj{np(str)} + {xp(perl)}
człapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
człapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
człapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
człapać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
człapać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
człapać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
człapać: _: : imperf: subj{np(str)} + {xp(perl)}
czmychać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
czmychać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
czmychnąć: _: : perf: subj{np(str)} + {np(dat)}
czmychnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
czmychnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
czmychnąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
czmychnąć: _: : perf: subj{np(str)} + {xp(abl)}
czmychnąć: _: : perf: subj{np(str)} + {xp(adl)}
czochrać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
czochrać się: _: : imperf: subj{np(str)} + {xp(locat)}
czochrać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
czochrać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
czochrać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
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)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
czubić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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)}
ćmić się: _: : imperf: {np(dat)} + {xp(locat)}
ćmić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
ćmić: _: : imperf: {np(str)} + {xp(locat)}
ćmić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ć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)}
darowywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
darowywać: _: : imperf: 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)}
decentralizować się: _: : imperf: subj{np(str)}
decentralizować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
dedukować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
dedukować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
dedukować: _: : imperf: subj{np(str)} + {or}
dedukować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
dedukować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
dedukować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
dedukować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(żeby2)}
dedukować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
dedukować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
dedukować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
dedukować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(żeby2)}
dedykować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat); prepnp(dla,gen)}
deficytowy: : : : {prepnp(w,acc)}
defilować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(przed,inst)}
defilować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
defilować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(przed,inst)}
defilować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
defilować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
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)}
defraudować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
deklasować się: _: : imperf: subj{np(str)}
deklasować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',ratr)}
deklasować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
deklasować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dekodować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dekoncentrować się: _: : imperf: subj{np(str)}
dekoncentrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dekoncentrować: _: : imperf: subj{np(str)} + {refl}
dekonspirować się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
dekonspirować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
dekonstruować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
delegować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)}
delegować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
delegować: _: : _: subj{np(str)} + obj{np(str)} + {xp(adl)}
delektować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
deliberować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
deliberować: _: : imperf: subj{np(str)} + {cp(int)}
deliberować: _: : imperf: subj{np(str)} + {cp(że)}
deliberować: _: : imperf: subj{np(str)} + {or}
deliberować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
deliberować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
demaskować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
demaskować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
demaskować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
demaskować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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}
demobilizować się: _: : imperf: subj{np(str)} + {advp(misc)}
demobilizować się: _: : imperf: subj{np(str)} + {np(inst)}
demobilizować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
demokratyzować się: _: : imperf: subj{np(str)}
demokratyzować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
denuncjować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
denuncjować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)} + {refl}
denuncjować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {np(dat)} + {or} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
denuncjować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
denuncjować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)}
denuncjować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {or}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {or}
denuncjować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
denuncjować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or} + {refl}
denuncjować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
depeszować: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {cp(int)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {cp(że)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(o,loc)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)} + {xp(abl)}
depeszować: _: : 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)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {xp(abl)}
depeszować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {or}
depeszować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,loc)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {prepadjp(po,postp)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
depeszować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {or}
depilować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
depilować się: _: : imperf: subj{np(str)} + {np(inst)}
depilować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
deprawować się: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
deprawować się: _: : imperf: subj{np(str)} + {xp(locat)}
deprawować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
deprawować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
deprawować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
deprecjonować się: _: : imperf: subj{np(str)}
deprecjonować: _: : imperf: subj{np(str)} + obj{np(str)}
deprymować się: _: : imperf: subj{np(str)} + {cp(int)}
deprymować się: _: : imperf: subj{np(str)} + {cp(że)}
deprymować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
deprymować: _: : imperf: subj{cp(gdy)} + {np(str)}
deprymować: _: : imperf: subj{cp(int)} + {np(str)}
deprymować: _: : imperf: subj{cp(jak)} + {np(str)}
deprymować: _: : imperf: subj{cp(kiedy)} + {np(str)}
deprymować: _: : imperf: subj{cp(że)} + {np(str)}
deprymować: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
deprymować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)} + {np(str)}
deptać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
deptać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
deptać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
deptać: _: : imperf: subj{np(str)} + {prepnp(koło,gen)}
deptać: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(za,inst)}
deptać: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
deptać: _: : imperf: subj{np(str)} + {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)}
deszyfrować: _: : imperf: subj{np(str)} + obj{np(str)}
determinować: _: : imperf: subj{np(str)} + {cp(int)}
determinować: _: : imperf: subj{np(str)} + {cp(że)}
determinować: _: : imperf: subj{np(str)} + {cp(żeby)}
determinować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
determinować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
detonować się: _: : imperf: subj{np(str)} + {np(inst)}
detonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
detonować: _: : imperf: subj{np(str)} + {refl}
detronizować się: _: : imperf: subj{np(str)}
detronizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
detronizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
detronizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
detronizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
detronizować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
dewaluować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
dewaluować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
dewastować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dezaktualizować się: _: : imperf: subj{np(str)}
dezaktualizować: _: : imperf: subj{np(str)} + obj{np(str)}
dezawuować się: _: : imperf: subj{np(str)}
dezawuować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
dezawuować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
dezerterować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jakoby)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
dezinformować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
dezintegrować się: _: : imperf: subj{np(str)}
dezintegrować: _: : imperf: subj{np(str)} + obj{np(str)}
dezorganizować się: _: : imperf: subj{np(str)}
dezorganizować: _: : 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)}
dezynfekować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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}
dializować: _: : imperf: subj{np(str)} + {advp(misc)} + {refl}
dializować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
dializować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dializować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dializować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
dialogować: _: : imperf: subj{np(str)} + {or}
dialogować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
dialogować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
dialogować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
dialogować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
dialogować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
dialogować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
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)}
dłużyć się: _: : imperf: controller{np(dat)} + controllee{infp(imperf)}
dłużyć się: _: : imperf: {np(dat)} + {xp(locat)}
dłużyć się: _: : imperf: subj{np(str)} + {np(dat)}
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)}
dnieć: _: : imperf: subj{E}
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)}
dobudzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
dobudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dobudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dobudzić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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}
dochodzić: _: : imperf: {prepnp(do,gen); prepncp(do,gen,że)}
dochodzić: _: : imperf: subj{cp(że); ncp(str,że)} + {prepnp(do,gen)}
dochodzić: _: : imperf: subj{np(str)} + {cp(int); ncp(gen,int)}
dochodzić: _: : imperf: subj{np(str)} + {cp(że); ncp(gen,że)}
dochodzić: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
dochodzić: _: : imperf: subj{np(str)} + {prepncp(do,gen,int)}
dochodzić: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
dochodzić: _: : imperf: subj{np(str)} + {xp(adl)}
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)}
dochrapać się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
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)}
dociążyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
dociskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
dociskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dociskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
docisnąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
docisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
docisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
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)}
doczekiwać się: _: : imperf: subj{np(str)} + {cp(aż)}
doczekiwać się: _: : imperf: subj{np(str)} + {cp(że)}
doczekiwać się: _: : imperf: subj{np(str)} + {cp(żeby)}
doczekiwać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,aż); ncp(gen,że); ncp(gen,żeby)}
doczekiwać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,aż); prepncp(na,acc,że); prepncp(na,acc,żeby)}
doczekiwać: _: : imperf: subj{np(str)} + {cp(aż)}
doczekiwać: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,aż); ncp(gen,że); ncp(gen,żeby)}
doczekiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
doczepiać się: _: : imperf: subj{np(str)} + {np(gen)}
doczepiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
doczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
doczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
doczepiać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
doczepić się: _: : perf: subj{np(str)} + {np(part)}
doczepić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
doczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doczepić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
doczłapać się: _: : perf: subj{np(str)} + {xp(adl)}
doczłapać: _: : perf: subj{np(str)} + {xp(adl)}
doczołgać się: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doczołgać: _: : perf: subj{np(str)} + obj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doczytać się: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
doczytać się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
doczytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doczytywać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(locat)}
doczytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
doczytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
doczytywać: _: : imperf: subj{np(str)} + obj{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}
dodrukować: _: : perf: subj{np(str)} + {np(part)}
dodrukować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
dogasać: _: : imperf: subj{np(str)}
dogasnąć: _: : perf: subj{np(str)}
dogaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
dognać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dognać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dognać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
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)}
dogryzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dogryzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dogryzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
dogryzać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
dogryzać: _: : imperf: subj{np(str)} + obj{np(str)}
dogryźć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dogryźć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
dogryźć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
dogryźć: _: : perf: subj{np(str)} + {np(dat)} + {or}
dogryźć: _: : perf: subj{np(str)} + obj{np(str)}
dogrzać się: _: : perf: subj{np(str)} + {np(inst)}
dogrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dogrzebać się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
dogrzebać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dogrzebywać się: _: : imperf: subj{np(str)} + {np(gen)}
dogrzebywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dogrzewać się: _: : imperf: subj{np(str)} + {np(inst)}
dogrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(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)}
doigrać: _: : perf: subj{np(str)} + {cp(że)}
doigrać: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że)}
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)}
dokańczać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
dokańczać: _: : imperf: subj{np(str)} + {cp(żeby)}
dokańczać: _: : imperf: subj{np(str)} + {np(gen)}
dokańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
dokańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
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)}
dokleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dokleić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {xp(locat)}
doklejać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
doklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
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}
dokooptować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dokooptować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dokooptować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dokopać się: _: : perf: subj{np(str)} + {np(gen)}
dokopać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
dokopać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dokopać: _: : perf: subj{np(str)} + {np(dat)} + {or}
dokopać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dokopywać się: _: : imperf: subj{np(str)} + {np(gen)}
dokopywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
dokopywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dokopywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
dokopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dokować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dokować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dokować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
dokować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
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)}
doktoryzować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {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)}
dokwaterować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dokwaterować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
dokwaterować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
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)}
doliczać się: _: : imperf: subj{np(str)} + {cp(int)}
doliczać się: _: : imperf: subj{np(str)} + {cp(że)}
doliczać się: _: : imperf: subj{np(str)} + {np(gen)}
doliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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ładowywać się: _: : imperf: subj{np(str)} + {np(inst)}
doładowywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
doładowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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łować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
dołować się: _: : imperf: subj{np(str)} + {cp(int)}
dołować się: _: : imperf: subj{np(str)} + {cp(że)}
dołować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dołować się: _: : imperf: subj{np(str)} + {or}
dołować: _: : imperf: subj{cp(gdy)} + {np(str)}
dołować: _: : imperf: subj{cp(int)} + {np(str)}
dołować: _: : imperf: subj{cp(jak)} + {np(str)}
dołować: _: : imperf: subj{cp(jeśli)} + {np(str)}
dołować: _: : imperf: subj{cp(kiedy)} + {np(str)}
dołować: _: : imperf: subj{cp(że)} + {np(str)}
dołować: _: : 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)}
dołować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
dołować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
dołować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dołować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
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)}
domieszać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
domieszać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
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)}
domknąć się: _: : perf: subj{np(str)} + {advp(misc)}
domknąć się: _: : perf: subj{np(str)} + {np(dat)}
domknąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
domknąć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
domknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
domknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
domknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
domknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
domknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
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)}
domówić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
domówić się: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
domówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
domówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
domówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
domówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
domówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
domówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
domówić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
domówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
domówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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}
domykać się: _: : imperf: subj{np(str)} + {advp(misc)}
domykać się: _: : imperf: subj{np(str)} + {np(dat)}
domykać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
domykać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
domykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
domykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
domykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
domykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
domykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
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)}
dopakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopakować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopakować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dopakowywać: _: : imperf: subj{np(str)} + obj{np(str)}
dopalać się: _: : imperf: subj{np(str)} + {np(inst)}
dopalać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dopalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopalić się: _: : perf: subj{np(str)}
dopalić: _: : perf: 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)}
dopatrzeć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby2)} + {prepnp(w,loc); prepncp(w,loc,że)}
dopatrzeć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
dopatrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
dopatrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
dopatrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby2)}
dopatrzeć: _: : perf: subj{np(str)} + {cp(int)}
dopatrzeć: _: : perf: subj{np(str)} + {cp(że)}
dopatrzeć: _: : perf: subj{np(str)} + {cp(żeby)}
dopatrzeć: _: : perf: 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)}
dopchać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dopchać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
dopchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dopchnąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
dopchnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
dopchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
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)}
dopędzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
dopędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
dopędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
dopędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
dopędzić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
dopędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
dopędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
dopiąć się: _: : perf: subj{np(str)} + {np(inst)}
dopiąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dopiąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
dopiąć: _: : perf: subj{np(str)} + {np(gen)}
dopiąć: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('na ostatni guzik')}
dopiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopiąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
dopić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
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)}
dopijać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
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)}
dopilnowywać: _: : imperf: subj{np(str)} + {cp(żeby)}
dopilnowywać: _: : imperf: subj{np(str)} + obj{np(gen)}
dopinać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
dopinać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'cel',natr)}
dopinać: _: : imperf: subj{np(str)} + {lexnp(gen,sg,'swój',natr)}
dopinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dopinać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'guzik',atr)}
dopinać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
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)}
dopomagać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
dopomagać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
dopomagać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dopomagać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
dopomagać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
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)}
doprawiać się: _: : imperf: subj{np(str)} + {np(inst)}
doprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
doprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
doprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
doprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
doprawić się: _: : perf: subj{np(str)} + {np(inst)}
doprawić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
doprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
dopychać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
dopychać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
dopychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
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)}
dorzynać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
dorzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dorżnąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
dorżnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
dorżnąć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
dorżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dosadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dosadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dosadzać: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
dosadzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dosadzić: _: : perf: subj{np(str)} + obj{np(part)} + {xp(locat)}
dosadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dosadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dosalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
dosalać: _: : imperf: subj{np(str)} + {preplexnp(do,gen,sg,'smak',natr)}
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ęgać: _: : imperf: subj{np(str)} + {np(gen)}
dosięgać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dosięgać: _: : imperf: subj{np(str)} + {np(str)} + {or}
dosięgać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dosięgać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
dosięgać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dosięgać: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
doskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
doskakiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
doskakiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
doskakiwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
doskoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
doskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
doskoczyć: _: : perf: subj{np(str)} + {xp(adl)}
doskonalić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
doskonalić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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ładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dosłodzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
dosłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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ługiwać się: _: : imperf: subj{np(str)} + {np(gen)}
dosługiwać: _: : imperf: subj{np(str)} + {xp(dur)}
dosłużyć się: _: : perf: subj{np(str)} + {np(gen)}
dosłużyć: _: : perf: subj{np(str)} + {xp(dur)}
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)}
dosolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
dosolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'smak',natr)}
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)}
dostawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
dostawiać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
dostawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,acc)}
dostawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
dosunąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
dosunąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dosuwać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
dosuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dosyłać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dosypać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
dosypiać: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
dosypywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
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)}
doszlusować: _: : perf: subj{np(str)} + {prepnp(do,gen)}
doszlusować: _: : perf: subj{np(str)} + {xp(adl)}
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śpiewać: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
dośpiewać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
dośpiewać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,_,'siebie',natr)}
dośpiewywać: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
dośpiewywać: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
dośpiewywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,_,'siebie',natr)}
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środkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dośrodkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dośrodkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
dośrodkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
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)}
doświetlać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
doświetlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
doświetlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
doświetlić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
doświetlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
doświetlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
dotańczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dotaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
dotaszczyć: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
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)}
douczać 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)}
douczać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
douczać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
douczać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
douczać się: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
douczać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
douczać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
douczać: _: : 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)}
douczać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
douczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
douczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
douczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
douczyć 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); prepnp(z,inst)}
douczyć się: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
douczyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
douczyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
douczyć się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
douczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
douczyć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
douczyć: _: : 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)}
douczyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
douczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
douczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
douczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dowalić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
dowalić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
dowalić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
dowalić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
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)}
doważyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
doważyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dowcipkować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
dowcipkować: _: : imperf: subj{np(str)} + {cp(że)}
dowcipkować: _: : imperf: subj{np(str)} + {or}
dowcipkować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
dowcipkować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,ż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)}
dowiercić się: _: : perf: subj{np(str)} + {xp(adl)}
dowiercić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
dozbroić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
dozbroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
dozwalać: _: : imperf: subj{np(str)} + obj,controllee{prepnp(na,acc); cp(żeby); infp(_)} + controller{np(dat)}
dozwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
dozwolić: _: : perf: subj{np(str)} + obj,controllee{prepnp(na,acc); cp(żeby); infp(_)} + controller{np(dat)}
dozwolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
drasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
drasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
drasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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)}
drętwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
drętwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drętwieć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'myśl',atr)}
drętwieć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'widok',atr)}
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)}
droczyć się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
droczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
droczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
droczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
droczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
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)}
drożyć się: _: : imperf: subj{np(str)}
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)}
drutować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
dryfować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
dryfować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
dryfować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
dryfować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
dryfować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
dryfować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(perl)}
dryfować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
drylować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
dubbingować: _: : imperf: subj{np(str)} + obj{np(str)}
dublować się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int)}
dublować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
durzyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
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)}
dworować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
dworować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
dworować: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
dworować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
dybać: _: : imperf: subj{np(str)} + {cp(żeby)}
dybać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
dygać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
dygać się: _: : imperf: subj{np(str)} + {np(gen)}
dygać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
dygać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dygać: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
dygnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
dygnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dygnąć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
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)}
dyndać się: _: : imperf: subj{np(str)} + {np(dat)}
dyndać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
dyndać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
dyndać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)}
dyndać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
dyndać: _: : imperf: subj{np(str)} + {np(inst)}
dyrdać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
dyrdać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dyrektorować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(dur)}
dyrektorować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
dyrektorować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
dyrektorować: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
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)}
dyskontować się: _: : imperf: subj{np(str)}
dyskontować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
dyskredytować: _: : imperf: subj{ncp(str,int); ncp(str,że)} + obj{np(str)}
dyskredytować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
dyskredytować: _: : imperf: subj{np(str)} + obj{ncp(str,int)}
dyskredytować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
dyskredytować: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
dywagować: _: : imperf: subj{np(str)} + {comprepnp(co do)}
dywagować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
dywagować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
dywagować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
dywagować: _: : imperf: subj{np(str)} + {cp(int)}
dywagować: _: : imperf: subj{np(str)} + {cp(że)}
dywagować: _: : imperf: subj{np(str)} + {or}
dywagować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
dywagować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
dywersyfikować się: _: : imperf: subj{np(str)}
dywersyfikować: _: : imperf: subj{np(str)} + obj{np(str)}
dyżurować: _: : imperf: subj{np(str)} + {xp(locat)}
dziabnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
dziabnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
dziabnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
dziabnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dziabnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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)}
dziecinnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dziecinnieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
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')}
dziergać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
dziergać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
dziergać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
dziurkować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
dziurkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dziwaczeć: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
dziwaczeć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
dziwaczeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
dziwaczyć: _: : imperf: subj{np(str)}
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)}
dziwować się: _: : imperf: subj{np(str)} + {np(dat); cp(int); cp(że); ncp(dat,int); ncp(dat,że)}
dziwować się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dziwować się: _: : imperf: subj{np(str)} + {or}
dziwować: _: : imperf: subj{cp(int)} + {np(str)}
dziwować: _: : imperf: subj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {np(str)}
dziwować: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
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źwięczeć: _: : imperf: {np(dat)} + {prepnp(w,loc)} + {xp(dur)}
dźwięczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {or}
dźwięczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)} + {or}
dźwięczeć: _: : imperf: subj{or} + {np(dat)} + {prepnp(w,loc)} + {xp(mod)}
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)}
egzaltować się: _: : imperf: {cp(że)} + {xp(locat)}
egzaltować się: _: : imperf: subj{np(str)} + {cp(gdy)}
egzaltować się: _: : imperf: subj{np(str)} + {cp(że)}
egzaltować się: _: : imperf: subj{np(str)} + {np(inst)}
egzaltować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
egzorcyzmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
egzystować: _: : imperf: subj{np(str)} + {prepnp(jako,str)}
egzystować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(w,loc)}
egzystować: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
egzystować: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(mod)}
ekranizować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
ekshumować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ekshumować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
ekskomunikować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)}
eksmitować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ekspediować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
eksplorować: _: : imperf: subj{np(str)} + {cp(int)}
eksplorować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
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)}
eksterminować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
eksterminować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ekstrahować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(z,gen)}
ekstrahować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ekstrahować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
emancypować się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
emancypować się: _: : imperf: subj{np(str)} + {prepnp(spod,gen)}
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)}
entuzjazmować się: _: : imperf: subj{np(str)} + {cp(int); cp(że)}
entuzjazmować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
entuzjazmować się: _: : imperf: subj{np(str)} + {or}
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)}
erygować: _: : perf: subj{np(str)} + obj{np(str)}
eskalować się: _: : imperf: subj{np(str)}
eskalować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
ewokować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
ewokować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ewokować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ewoluować: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(przez,acc)} + {xp(adl)}
ewoluować: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,gen)} + {xp(adl)}
fabrykować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
fabrykować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
fabularyzować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
faksować: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {cp(int)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {cp(że)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {xp(abl)}
faksować: _: : 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)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {or}
faksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
faksować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {prepadjp(po,postp)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {xp(abl)} + {xp(adl)}
faksować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {or}
fakturować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
fakturować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
fakturować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
fakturować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
falować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
falować: _: : imperf: subj{np(str)} + obj{np(str)}
fałdować się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
fałdować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
fałdować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
fałdować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
fałdować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
fałdować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
fantazjować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
fantazjować: _: : imperf: subj{np(str)} + {cp(int)}
fantazjować: _: : imperf: subj{np(str)} + {cp(jak)}
fantazjować: _: : imperf: subj{np(str)} + {cp(że)}
fantazjować: _: : imperf: subj{np(str)} + {or}
fantazjować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
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)}
fasować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)} + {prepnp(z,gen)}
fasować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
fasować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
fasować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
fastrygować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
faszyzować się: _: : imperf: subj{np(str)}
faszyzować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
fetować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
figlować: _: : imperf: subj{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)}
filować: _: : imperf: subj{np(str)} + {cp(int)} + {xp(abl)} + {xp(perl)}
filować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(abl)} + {xp(perl)}
filować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)} + {xp(perl)}
filować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
filozofować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
filozofować: _: : imperf: subj{np(str)} + {cp(int)}
filozofować: _: : imperf: subj{np(str)} + {cp(że)}
filozofować: _: : imperf: subj{np(str)} + {or}
filozofować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
filtrować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
filtrować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
filtrować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
filtrować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
filtrować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
filtrować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
filtrować się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
filtrować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
fingować: _: : imperf: subj{np(str)} + obj{np(str)}
finiszować: _: : _: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,loc)}
finiszować: _: : _: subj,controller{np(str)} + controllee{xp(mod)} + {xp(temp)}
finiszować: _: : _: subj{np(str)} + {adjp(str)} + {prepnp(w,loc)}
finiszować: _: : _: subj{np(str)} + {np(inst)}
finiszować: _: : _: subj{np(str)} + {np(str)}
finiszować: _: : _: subj{np(str)} + {prepnp(ku,dat)}
finiszować: _: : _: subj{np(str)} + {prepnp(na,loc)} + {prepnp(w,loc)}
finiszować: _: : _: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
firmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
flankować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
foliować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
foliować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
fragment: : : : {np(gen); prepnp(w,loc); prepnp(z,gen)} + {comprepnp(co do)}
fragment: : : : {np(gen); prepnp(w,loc); prepnp(z,gen)} + {comprepnp(na temat)}
fragment: : : : {np(gen); prepnp(w,loc); prepnp(z,gen)} + {cp(jak)}
fragment: : : : {np(gen); prepnp(w,loc); prepnp(z,gen)} + {cp(że)}
fragment: : : : {np(gen); prepnp(w,loc); prepnp(z,gen)} + {or}
fragment: : : : {np(gen); prepnp(w,loc); prepnp(z,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
fragment: : : : {np(gen); prepnp(w,loc); prepnp(z,gen)} + {xp(abl)} + {xp(adl)}
frapować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
frapować: _: : imperf: subj{cp(int); ncp(str,int)} + {np(str)}
frapować: _: : imperf: subj{cp(że); ncp(str,że)} + {np(str)}
frapować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
frasować się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
frasować się: _: : imperf: subj{np(str)} + {cp(int)}
frasować się: _: : imperf: subj{np(str)} + {cp(że)}
frasować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
frasować się: _: : imperf: subj{np(str)} + {or}
frasować się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
frasować: _: : imperf: subj{cp(gdy)} + {np(str)}
frasować: _: : imperf: subj{cp(int)} + {np(str)}
frasować: _: : imperf: subj{cp(jak)} + {np(str)}
frasować: _: : imperf: subj{cp(jeśli)} + {np(str)}
frasować: _: : imperf: subj{cp(kiedy)} + {np(str)}
frasować: _: : imperf: subj{cp(że)} + {np(str)}
frasować: _: : 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)}
frasować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
frezować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
frezować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
froterować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
frunąć: _: : _: subj{np(str)} + {prepnp(na,loc)}
frunąć: _: : _: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
frymarczyć: _: : imperf: subj{np(str)} + {np(inst)}
fukać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
fukać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
fukać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
fuknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
fuknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
fuknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
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)}
furczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
furczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
furczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
furknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
furknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
furknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
furknąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
furkotać: _: : imperf: subj{np(str)} + {np(inst)}
furkotać: _: : imperf: subj{np(str)} + {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)}
galwanizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ganiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
ganiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(perl)}
ganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
ganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
ganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
ganiać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
ganiać: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
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)}
garbić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
garbić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
garbić się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
garbić: _: : imperf: subj{np(str)} + obj{np(str)}
garbować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gardłować: _: : imperf: subj{np(str)} + {cp(int)}
gardłować: _: : imperf: subj{np(str)} + {cp(że)}
gardłować: _: : imperf: subj{np(str)} + {cp(żeby)}
gardłować: _: : imperf: subj{np(str)} + {or}
gardłować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
gardłować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
gardłować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że)}
gardłować: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
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)}
gaworzyć: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
gaworzyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
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)}
gdakać: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
gdakać: _: : imperf: subj{np(str)} + {cp(int)}
gdakać: _: : imperf: subj{np(str)} + {cp(jak)}
gdakać: _: : imperf: subj{np(str)} + {cp(że)}
gdakać: _: : imperf: subj{np(str)} + {cp(żeby)}
gdakać: _: : imperf: subj{np(str)} + {or}
gdakać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
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)}
generalizować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
generalizować: _: : imperf: subj{np(str)} + {comprepnp(co do)}
generalizować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
generalizować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
generalizować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
generalizować: _: : imperf: subj{np(str)} + {cp(int)}
generalizować: _: : imperf: subj{np(str)} + {cp(że)}
generalizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
generalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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ęgać: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {cp(że)}
gęgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
gęgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
gęgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
gęgać: _: : imperf: subj{np(str)} + obj{or} + {np(dat)} + {prepnp(o,loc)}
gęgać: _: : imperf: subj{np(str)} + obj{or} + {prepnp(do,gen)} + {prepnp(o,loc)}
gęgać: _: : imperf: subj{np(str)} + obj{or} + {prepnp(o,loc)} + {prepnp(z,inst)}
gęgać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
gęgać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
gęgać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {cp(że)}
gęgać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
gęgać: _: : imperf: subj{np(str)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
gęgać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {cp(że)}
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)}
gibać się: _: : imperf: subj{np(str)} + {xp(adl)}
gibać: _: : imperf: {np(inst)} + {xp(adl)}
gibać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
gipsować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
glansować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
glansować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ględzić: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
ględzić: _: : imperf: subj{np(str)} + {nonch}
ględzić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
globalizować się: _: : imperf: subj{np(str)} + {np(dat)}
globalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
głuszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
gmerać się: _: : imperf: subj{np(str)}
gmerać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
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)}
gnoić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
gnoić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gnoić: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
gnuśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
gnuśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
gnuśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
golnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(part)} + {prepnp(z,gen)}
golnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
gorączkować się: _: : imperf: subj{np(str)} + {cp(int)}
gorączkować się: _: : imperf: subj{np(str)} + {cp(że)}
gorączkować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
gorączkować się: _: : imperf: subj{np(str)} + {or}
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)}
gorszyć się: _: : imperf: subj{np(str)} + {cp(int)}
gorszyć się: _: : imperf: subj{np(str)} + {cp(że)}
gorszyć się: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,acc); ncp(inst,int); ncp(inst,że)}
gorszyć się: _: : imperf: subj{np(str)} + {or}
gorszyć: _: : imperf: subj{cp(int)} + {np(str)}
gorszyć: _: : imperf: subj{cp(że)} + {np(str)}
gorszyć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
gorszyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
gorzknieć: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'skutek',atr)}
gorzknieć: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
gorzknieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
gorzknieć: _: : imperf: subj{np(str)} + {prepnp(wskutek,gen)}
gorzknieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
gospodarować: _: : imperf: subj{np(str)} + {np(inst)}
gospodarować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
gospodarować: _: : imperf: subj{np(str)} + {xp(locat)}
gospodarzyć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
gospodarzyć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
gospodarzyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
gospodarzyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {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)}
grabieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
grabieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
grabieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
gracować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
gramolić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
gramolić się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
granatowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
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)}
grawerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
grawitować: _: : imperf: subj{np(str)} + {xp(adl)}
grillować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
grillować się: _: : imperf: subj{np(str)} + {xp(locat)}
grillować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
grillować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
grodzić się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
grodzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
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}
grubieć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
grubieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
grubieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
grubieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
grubieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
grubieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
gruchotać: _: : imperf: {np(dat)} + {xp(locat)}
gruchotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gruchotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
gruchotać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
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)}
gruntować się: _: : imperf: subj{np(str)} + {np(dat)}
gruntować się: _: : imperf: subj{np(str)} + {np(inst)}
gruntować się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
gruntować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
gruntować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gruntować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
gruntować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
grupować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
grupować się: _: : imperf: subj{np(str)} + {xp(locat)}
grupować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',ratr)}
grupować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
grupować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
grymasić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
grymasić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
grymasić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
grypsować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
grypsować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
grypsować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(jak)}
grypsować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
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)}
gryzmolić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {cp(int)}
gryzmolić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
gryzmolić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {cp(żeby)}
gryzmolić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {or}
gryzmolić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
gryzmolić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
gryzmolić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {prepadjp(po,postp)}
gryzmolić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
gulgotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
gulgotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
gulgotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
gulgotać: _: : imperf: subj{np(str)} + {xp(locat)}
gumować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gustować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
guzdrać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
guzdrać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
guzdrać się: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
gwintować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
gzić: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
habilitować: _: : _: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)} + {xp(temp)}
habilitować: _: : _: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)} + {xp(temp)}
habilitować: _: : _: subj{np(str)} + {xp(locat)} + {xp(temp)} + {preplexnp(na,loc,sg,'podstawa',ratr)}
habilitować: _: : _: subj{np(str)} + {xp(locat)} + {xp(temp)} + {preplexnp(w,loc,sg,'zakres',ratr)}
habilitować: _: : _: subj{np(str)} + {xp(locat)} + {xp(temp)} + {preplexnp(z,gen,sg,'zakres',ratr)}
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)}
hałasować: _: : imperf: subj{np(str)} + {cp(że)}
hałasować: _: : imperf: subj{np(str)} + {cp(żeby)}
hałasować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
hałasować: _: : imperf: subj{np(str)} + {or}
hałasować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
hałasować: _: : imperf: subj{np(str)} + {xp(mod)}
hamletyzować: _: : imperf: subj{np(str)} + {cp(że)}
hamletyzować: _: : imperf: subj{np(str)} + {or}
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)}
hańbić: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
hańbić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
hańbić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {refl}
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)}
harować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(dur)}
harować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
harować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(mod)}
harować: _: : imperf: subj{np(str)} + {fixed('za dwóch')}
harować: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
harować: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(locat)}
harować: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {cp(żeby)}
harować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)} + {xp(mod)}
hartować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
hartować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
hartować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
hartować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
hartować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
hartować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
hartować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
hartować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
hartować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
hartować: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {refl}
hartować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
hartować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
hasać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
hasać: _: : imperf: subj{np(str)} + {xp(locat)}
hasać: _: : imperf: subj{np(str)} + {xp(perl)}
heblować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
hierarchizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
hierarchizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
hipnotyzować: _: : 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)}
homogenizować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
homogenizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
homogenizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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}
hospitować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
hukać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
hukać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
hukać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
hukać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
hukać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
hukać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
hukać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
hukać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
hukać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
hukać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
hukać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
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)}
imaginować: _: : imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
imaginować: _: : imperf: subj{np(str)} + {cp(jak)} + {lexnp(dat,_,'siebie',natr)}
imaginować: _: : imperf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
imaginować: _: : imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
imaginować: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
imaginować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
imaginować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {lexnp(dat,_,'siebie',natr)}
imigrować: _: : _: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
imitować: _: : imperf: subj,controller{np(str)} + controllee{np(str)}
imitować: _: : imperf: subj{np(str)} + {cp(int)}
imitować: _: : imperf: subj{np(str)} + {cp(że)}
imitować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
immatrykulować się: _: : _: subj{np(str)} + {xp(locat)}
immatrykulować: _: : _: subj{np(str)} + obj{np(str)}
implantować się: _: : _: subj{np(str)} + {xp(locat)}
implantować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)}
implantować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
implementować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
implementować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
implementować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
imponować: _: : imperf: subj{cp(int)} + {np(dat)}
imponować: _: : imperf: subj{cp(jak)} + {np(dat)}
imponować: _: : imperf: subj{cp(że)} + {np(dat)}
imponować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
imponować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
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)}
imprezować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
imprezować: _: : imperf: subj{np(str)} + {xp(dur)}
imprezować: _: : imperf: subj{np(str)} + {xp(locat)}
imprezować: _: : imperf: subj{np(str)} + {xp(temp)}
improwizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
improwizować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
improwizować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
improwizować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
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)}
indagować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
indagować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
indagować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
indagować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
indagować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
indagować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
indagować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
indeksować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
indeksować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
indeksować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
indeksować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(względem,gen)}
indoktrynować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
indoktrynować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
indoktrynować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
indoktrynować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
indukować się: _: : imperf: subj{np(str)} + {xp(locat)}
indukować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
indukować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
infiltrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
infiltrować: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {xp(perl)}
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)}
interpelować: _: : imperf: subj{np(str)} + {cp(że)}
interpelować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
interpelować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby); prepncp(o,acc,żeby)}
interpelować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
interpelować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
interpelować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
interpolować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
interpolować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
interpolować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
interpolować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
interpolować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
interpolować: _: : imperf: subj{np(str)} + {xp(adl)}
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)}
intonować: _: : imperf: subj{np(str)} + {np(inst)} + {or}
intonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
inwigilować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
inwigilować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
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)}
iskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
iskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
iskać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
iskać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
iskrzyć się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
iskrzyć się: _: : imperf: subj{np(str)} + {np(inst)}
iskrzyć się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
iskrzyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
iskrzyć się: _: : imperf: subj{np(str)} + {xp(locat)}
iskrzyć: _: : imperf: {preplexnp(na,loc,sg,'linia',atr)}
iskrzyć: _: : imperf: {prepnp(między,inst)}
iskrzyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
iskrzyć: _: : imperf: subj{np(str)} + {np(inst)}
iskrzyć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
iskrzyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
iskrzyć: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
jazgotać: _: : imperf: subj{np(str)} + {cp(że)}
jazgotać: _: : imperf: subj{np(str)} + {cp(żeby)}
jazgotać: _: : imperf: subj{np(str)} + {np(inst)}
jazgotać: _: : imperf: subj{np(str)} + {or}
jazgotać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {nonch}
jazgotać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
jazgotać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {nonch}
jazzować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
jąć się: _: : perf: subj{np(str)} + {np(gen)}
jąć: _: : perf: subj,controller{E} + controllee{infp(imperf)}
jąkać się: _: : imperf: subj{np(str)} + {cp(że)}
jąkać się: _: : imperf: subj{np(str)} + {np(inst)}
jąkać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
jąkać się: _: : imperf: subj{np(str)} + {xp(mod)}
jątrzyć się: _: : imperf: subj{np(str)}
jątrzyć: _: : imperf: subj{np(str)} + {np(inst)}
jątrzyć: _: : imperf: subj{np(str)} + obj{np(str)}
jątrzyć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
jątrzyć: _: : imperf: subj{np(str)} + {xp(locat)}
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')}
jednać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
jednać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
jednać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
jednać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
jeżyć się: _: : imperf: subj{lexnp(str,_,'włos',atr)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)} + {preplexnp(na,loc,sg,'głowa',atr)}
jeżyć się: _: : imperf: subj{lexnp(str,_,'włos',atr)} + {np(dat)} + {preplexnp(na,acc,sg,'widok',natr)} + {preplexnp(na,loc,sg,'głowa',atr)}
jeżyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
jeżyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
jeżyć się: _: : imperf: subj{np(str)} + {np(inst)}
jeżyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
jeżyć się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
jeżyć się: _: : imperf: subj{np(str)} + {xp(abl)}
jeżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
judzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
judzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
judzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
judzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
kablować: _: : imperf: subj{np(str)} + {cp(że)}
kablować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
kablować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
kablować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
kadrować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
kadrować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
kadzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
kadzić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
kadzić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
kajać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
kajać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
kajać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
kajać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
kaligrafować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {xp(locat)}
kaligrafować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kaligrafować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {xp(mod)}
kaligrafować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {or}
kaligrafować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {or}
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)}
kamienieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
kamienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
kamienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
kamienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
kamienieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
kamienować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
kamuflować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
kamuflować się: _: : imperf: subj{np(str)} + {np(inst)}
kamuflować się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
kamuflować się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
kamuflować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kamuflować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kamuflować się: _: : imperf: subj{np(str)} + {xp(locat)}
kamuflować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
kamuflować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kamuflować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
kamuflować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
kamuflować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
kamuflować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
kamuflować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kamuflować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
kandyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kanonizować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
kantować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
kantować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kantować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kantować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
kantować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
kantować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
kapitalizować się: _: : imperf: subj{np(str)} + {advp(misc)}
kapitalizować się: _: : imperf: subj{np(str)} + {xp(locat)}
kapitalizować się: _: : imperf: subj{np(str)} + {xp(temp)}
kapitalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
kapitalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kapitalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kapitalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
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)}
kaptować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kaptować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
kaptować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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)}
karbować się: _: : imperf: subj{np(str)}
karbować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
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)}
karleć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
karleć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
karleć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
karleć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(pod,inst)}
karleć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
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)}
kasłać: _: : imperf: subj{np(str)} + {advp(misc)}
kasłać: _: : imperf: subj{np(str)} + {np(inst)}
kasłać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
kasłać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
kasłać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kasłać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
kasłać: _: : imperf: subj{np(str)} + {xp(adl)}
kasłać: _: : imperf: subj{np(str)} + {xp(mod)}
kasłać: _: : imperf: subj{np(str)} + {xp(temp)}
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)}
kastrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kaszlać: _: : imperf: subj{np(str)}
kaszleć: _: : imperf: subj{np(str)} + {np(inst)}
kaszlnąć: _: : perf: subj{np(str)} + {np(inst)}
katalizować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
katalizować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
katalizować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
katalizować się: _: : imperf: subj{np(str)} + {xp(locat)}
katalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
katalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
katalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
katalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
katalogować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
katalogować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
katalogować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
katalogować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
katapultować się: _: : _: subj{np(str)} + {xp(abl)} + {xp(adl)}
katapultować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
kategoryzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
kategoryzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
kategoryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
kategoryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kategoryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
kategoryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
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)}
kicać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
kicać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
kicać: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(mod)}
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)}
kichnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
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)}
kisić się: _: : imperf: subj{np(str)} + {xp(locat)}
kisić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kisnąć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kisnąć: _: : imperf: subj{np(str)} + {xp(locat)}
kitować: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
kitować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
kitować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
kitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
klarować się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
klarować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
klarować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
klarować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
klarować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
klarować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
klasnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
klasnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
klasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klasnąć: _: : perf: 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)}
kląskać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
kląskać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
kląskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
kląskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
kląskać: _: : imperf: subj{np(str)} + obj{np(str)}
kląskać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
kląskać: _: : imperf: subj{np(str)} + {xp(locat)}
klecić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
klecić się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
klecić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
klecić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
kluć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kluć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
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łapać: _: : imperf: subj{np(str)} + {np(inst)} + {comprepnp(na temat)}
kłapać: _: : imperf: subj{np(str)} + {np(inst)} + {or}
kłapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kłapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
kłapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
kłapnąć: _: : perf: subj{np(str)} + {np(inst)} + {comprepnp(na temat)}
kłapnąć: _: : perf: subj{np(str)} + {np(inst)} + {or}
kłapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kłapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
kłapnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
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)}
knocić się: _: : imperf: subj{np(str)}
knocić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
knować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
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)}
koegzystować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
koić się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
koić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
koić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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}
kolaborować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
kolacjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kolczykować się: _: : imperf: subj{np(str)}
kolczykować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
kolektywizować się: _: : imperf: subj{np(str)}
kolektywizować: _: : imperf: subj{np(str)} + obj{np(str)}
kolędować: _: : imperf: subj{np(str)} + {cp(żeby)}
kolędować: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
kolędować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
kolędować: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
kolędować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kolędować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
kolorować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
kolorować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
kolorować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
koloryzować: _: : imperf: subj{np(str)} + {cp(że)}
koloryzować: _: : imperf: subj{np(str)} + {cp(żeby)}
koloryzować: _: : imperf: subj{np(str)} + obj{np(str)}
koloryzować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kolportować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(locat)}
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łować się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {prepnp(w,loc)}
kołować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
kołować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kołować: _: : imperf: subj{np(str)} + {np(inst)}
kołować: _: : imperf: subj{np(str)} + obj{np(str)}
kołować: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
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)}
komenderować: _: : imperf: subj{np(str)} + {cp(żeby)}
komenderować: _: : imperf: subj{np(str)} + {np(inst)}
komenderować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
komenderować: _: : imperf: subj{np(str)} + {or}
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}
komercjalizować się: _: : imperf: subj{np(str)}
komercjalizować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
kompensować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kompensować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
kompensować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc); prepncp(przez,acc,że)}
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)}
kompilować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kompilować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
kompilować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
kompilować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
kompilować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
kompresować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kompresować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
kompresować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kompresować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
komunizować się: _: : imperf: subj{np(str)}
komunizować: _: : imperf: subj{np(str)} + obj{np(str)}
komutować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
koncypować: _: : imperf: subj{np(str)} + {cp(int)}
koncypować: _: : imperf: subj{np(str)} + {cp(że)}
koncypować: _: : imperf: subj{np(str)} + {cp(żeby)}
koncypować: _: : imperf: subj{np(str)} + obj{np(str)}
kondensować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(w,acc)}
kondensować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kondensować się: _: : imperf: subj{np(str)} + {xp(locat)}
kondensować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)}
kondensować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(w,acc)}
kondensować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
kondensować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kondensować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
konferować: _: : imperf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
konferować: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(z,inst)}
konferować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
konferować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
konferować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
konferować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
konferować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
konferować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
konfigurować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
konfigurować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
konfigurować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
konfigurować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
konfigurować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
konfigurować: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
konotować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
konotować się: _: : imperf: subj{np(str)} + {xp(locat)} + {advp(misc)}
konotować: _: : imperf: subj{np(str)} + obj{np(str); cp(że)} + {np(dat)}
konotować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
konotować: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
konserwować się: _: : imperf: subj{np(str)}
konserwować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
konserwować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
konserwować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
konspirować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
konspirować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
konspirować się: _: : imperf: subj{np(str)} + {xp(locat)}
konspirować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
konspirować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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}
kontentować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
kontentować: _: : imperf: subj{cp(int)} + {np(str)}
kontentować: _: : imperf: subj{cp(że)} + {np(str)}
kontentować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
kontentować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
kontrować: _: : imperf: subj{np(str)} + {cp(że)}
kontrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kontrować: _: : imperf: subj{np(str)} + {or}
kontuzjować się: _: : _: subj{np(str)}
kontuzjować: _: : _: subj{np(str)} + obj{np(str)}
kontynuować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
konwersować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
konwersować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
konwersować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
konwersować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
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)}
kopcić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kopcić się: _: : imperf: subj{np(str)} + {xp(abl)}
kopcić się: _: : imperf: subj{np(str)} + {xp(locat)}
kopcić: _: : imperf: subj{np(str)} + {np(dat)}
kopcić: _: : imperf: subj{np(str)} + obj{np(inst)}
kopcić: _: : imperf: subj{np(str)} + obj{np(str)}
kopcić: _: : imperf: subj{np(str)} + {xp(abl)}
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)}
kopulować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
korodować: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
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}
korzyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc)}
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)}
kostnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
kostnieć: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
kostnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
kostnieć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kostnieć: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
kotłować się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
kotłować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
kotłować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kotłować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kotłować: _: : imperf: subj{np(str)} + obj{np(str)}
kotłować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
kotwiczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
kotwiczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kotwiczyć: _: : imperf: subj{np(str)} + {xp(adl)}
kotwiczyć: _: : imperf: subj{np(str)} + {xp(locat)}
kować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
koziołkować się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
koziołkować: _: : imperf: subj{np(str)} + {np(inst)}
koziołkować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
koziołkować: _: : imperf: subj{np(str)} + {xp(perl)}
kozłować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
kozłować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
kozłować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
kozłować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
kozłować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
kozłować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kozłować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
kozłować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
kozłować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
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)}
krakać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
krakać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
krakać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
krakać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
krakać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
krakać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
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)}
kropnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
kropnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
kropnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
kropnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
kropnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kropnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
kropnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
kropnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
kruszeć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
kruszeć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
kruszeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
kruszeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
kruszeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
kruszeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
kruszeć: _: : imperf: subj{np(str)} + {np(dat)} + {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)}
krygować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
krygować się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
krystalizować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
krystalizować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
krystalizować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
krystalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
krystalizować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
krzepić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
krzepić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
krzepnąć: _: : imperf: subj{np(str)} + {np(dat)}
krzesać się: _: : imperf: subj{np(str)} + {xp(abl)}
krzesać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
krzesać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
krzesać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
krzesać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
krzewić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
krzewić się: _: : imperf: subj{np(str)} + {xp(locat)}
krzewić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
krzewić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
krztusić się: _: : imperf: subj{np(str)} + {np(inst)} + {or}
krztusić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {or}
krztusić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
krztusić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
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)}
kucać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
kucać: _: : imperf: subj{np(str)} + {xp(locat)}
kucharzyć: _: : imperf: subj{np(str)}
kucnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
kucnąć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
kukać: _: : imperf: subj{np(str)}
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)}
kumać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
kumać: _: : imperf: subj{np(str)} + {cp(int)}
kumać: _: : imperf: subj{np(str)} + {cp(że)}
kumać: _: : imperf: subj{np(str)} + {np(str)}
kumkać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
kumkać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
kumkać: _: : imperf: subj{np(str)} + {xp(locat)}
kumkać: _: : imperf: subj{np(str)} + {xp(mod)}
kumkać: _: : imperf: {xp(locat)}
kumplować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
kupczyć: _: : imperf: subj{np(str)} + {np(inst)}
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)}
kurować się: _: : imperf: subj{np(str)} + {np(inst)}
kurować się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
kurować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kurować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
kurzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
kurzyć się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
kurzyć się: _: : imperf: subj{np(str)} + {xp(abl)}
kurzyć się: _: : imperf: subj{np(str)} + {xp(locat)}
kurzyć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
kurzyć: _: : imperf: subj{np(str)} + {np(inst)}
kurzyć: _: : imperf: subj{np(str)} + obj{np(str)}
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}
kuśtykać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
kuśtykać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
kuśtykać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)} + {xp(perl)}
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)}
kwaśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',atr)}
kwaśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
kwaśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
kwaśnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
kwaśnieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
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)}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
kwękać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
kwiczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
kwiczeć: _: : imperf: subj{np(str)} + {or}
kwiczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
kwiknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
kwiknąć: _: : perf: subj{np(str)} + {or}
kwiknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
kwilić: _: : imperf: subj{np(str)} + {cp(int)}
kwilić: _: : imperf: subj{np(str)} + {cp(że)}
kwilić: _: : imperf: subj{np(str)} + {or}
kwilić: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
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}
kwotować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
lakować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
laminować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
laminować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
lec: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'gruz',natr)}
lec: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
lec: _: : perf: subj{np(str)} + {prepnp(u,gen)}
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)}
legitymizować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
legitymizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
legitymizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
legitymizować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)} + {refl}
legitymować się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
legitymować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
legitymować się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
legitymować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
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)}
lewicować: _: : imperf: subj{np(str)}
lewitować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
lewitować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(nad,inst)}
lewitować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
lewitować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
leźć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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ęgnąć: _: : 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)}
licytować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int)} + {prepnp(z,inst)}
licytować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)} + {prepnp(z,inst)}
licytować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
licytować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
limitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
limitować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
linczować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
linieć: _: : imperf: subj{np(str)}
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)}
logować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
logować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
logować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
logować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
lśnić się: _: : imperf: subj{np(str)} + {np(inst)}
lśnić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
lśnić: _: : imperf: subj{np(str)} + {np(inst)}
lśnić: _: : imperf: subj{np(str)} + {prepnp(od,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)}
lukrować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)} + {refl}
lukrować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
lukrować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {xp(locat)}
lukrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
lulać: _: : imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
lulać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {preplexnp(do,gen,sg,'sen',atr)}
lulać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(u,gen)}
lulać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
lulać: _: : imperf: subj{np(str)} + {xp(locat)}
lunąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepnp(w,acc)}
lunąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepnp(w,acc)}
lunąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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}
lutować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
lutować się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
lutować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
lutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
lutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
lutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
lutować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
lutować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
luzować się: _: : imperf: subj{np(str)} + {np(dat)}
luzować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
luzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
luzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
luzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
luzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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}
łajdaczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
łajdaczyć się: _: : imperf: subj{np(str)} + {xp(locat)}
ł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)}
łakomić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
ł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)}
łapać się: _: : imperf: subj{np(str)} + {np(gen)}
łapać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
łapać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
łapać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
łapać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
łapać: _: : imperf: subj{np(str)} + {cp(int)}
łapać: _: : imperf: subj{np(str)} + {cp(że)}
łapać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
łapać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
łapać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
łapać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
łapać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
łapać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ł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)}
łgać: _: : imperf: subj{np(str)} + {cp(że)}
łgać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'oko',ratr)}
łgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(mod)}
łgać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(mod)} + {or}
ł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}
łomotać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
łomotać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
łomotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
łomotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
łomotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(mod)}
łomotać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
łomotać: _: : imperf: subj{or} + {np(dat)} + {xp(locat)}
łomotnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
łomotnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
łomotnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
łomotnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
łomotnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
łomotnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
łomotnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
łopotać: _: : imperf: subj{np(str)} + {np(inst)}
łopotać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
łopotać: _: : imperf: subj{np(str)} + {xp(locat)}
ł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)}
łupać: _: : imperf: {np(str)} + {xp(locat)}
łupać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
łupać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
łupać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
łupać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
łupać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
łupać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
łupić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
łupić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
łupić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
łupić: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
łupnąć: _: : perf: {np(str)} + {xp(locat)}
łupnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
łupnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
łupnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
łupnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
łuskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
łuskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
łuskać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
łuszczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
łuszczyć się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
łuszczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ł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)}
łypać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(inst,_,'oko',atr)}
łypać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)} + {lexnp(inst,_,'oko',atr)}
łypać: _: : imperf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'oko',atr)}
łypnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(inst,_,'oko',atr)}
łypnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)} + {lexnp(inst,_,'oko',atr)}
łypnąć: _: : perf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'oko',atr)}
łysieć: _: : imperf: subj{np(str)} + {np(dat)}
łysieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
łysieć: _: : imperf: subj{np(str)} + {xp(locat)}
łysieć: _: : imperf: subj{np(str)} + {xp(mod)}
łyskać się: _: : imperf: {xp(locat)}
łyskać: _: : imperf: subj{np(str)} + {np(inst)}
łyskać: _: : imperf: subj{np(str)} + {xp(abl)}
łyskać: _: : imperf: subj{np(str)} + {xp(locat)}
łyskać: _: : imperf: {xp(locat)}
łzawić: _: : imperf: subj{lexnp(str,_,'oko',atr)} + {np(dat)} + {prepnp(od,gen); prepnp(z,gen); preplexnp(z,gen,sg,'powodu',ratr)}
łzawić: _: : imperf: subj{np(str)}
macać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
macać: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
macać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
macać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
macać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
macać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
macać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
macać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
macać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)} + {refl}
macać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
magazynować się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
magazynować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
magazynować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
maglować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
maglować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
maglować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
maglować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
maglować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
maglować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
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)}
majsterkować: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
majsterkować: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
majsterkować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
majsterkować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
majtać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
majtać: _: : imperf: subj{np(str)} + {np(inst)}
majtać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
maksymalizować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
maltretować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
maltretować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
mamrotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(pod,inst,sg,'nos',natr)}
mamrotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
mamrotać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'nos',natr)} + {or}
mamrotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
mamrotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {preplexnp(pod,inst,sg,'nos',natr)}
mamrotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {xp(adl)}
mamrotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {preplexnp(pod,inst,sg,'nos',natr)}
mamrotać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(adl)}
mamrotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)} + {preplexnp(pod,inst,sg,'nos',natr)}
mamrotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {preplexnp(pod,inst,sg,'nos',natr)}
mamrotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {preplexnp(pod,inst,sg,'nos',natr)}
mamrotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,sg,'nos',natr)} + {or}
mamrotać: _: : imperf: subj{np(str)} + {xp(mod)} + {or}
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)}
manewrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
manewrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
manewrować: _: : imperf: subj{np(str)} + {xp(mod)}
manifestować się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
manifestować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
manifestować się: _: : imperf: subj{np(str)} + {xp(locat)}
manifestować: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
manifestować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,żeby)}
manifestować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
manipulować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
manipulować: _: : imperf: subj{np(str)} + obj{np(inst)}
marginalizować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
marginalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
markować: _: : imperf: subj{np(str)} + {cp(że)}
markować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
markować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
marnieć: _: : imperf: subj{np(str)} + {np(dat)}
marnieć: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
marnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
marnieć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
marnieć: _: : imperf: subj{np(str)} + {xp(locat)}
marnieć: _: : imperf: subj{np(str)} + {xp(mod)}
marnieć: _: : imperf: subj{np(str)} + {xp(temp)}
marnotrawić się: _: : imperf: subj{np(str)}
marnotrawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
marnotrawić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
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)}
martwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
martwieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
marynować się: _: : imperf: subj{np(str)} + {np(inst)}
marynować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
maskować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
maskować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
maskować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
maskować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
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)}
materializować się: _: : imperf: subj{np(str)} + {xp(locat)}
matkować: _: : imperf: subj{np(str)} + {np(dat)}
matować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
matowieć: _: : imperf: subj{np(str)}
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)}
maznąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
maznąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
maznąć: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
mącić się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {prepnp(w,loc)}
mącić się: _: : imperf: subj{np(str)}
mącić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
mącić: _: : imperf: subj{np(str)} + obj{np(str)}
mącić: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
mącić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
mądrzyć się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
mądrzyć się: _: : imperf: subj{np(str)} + {cp(int)}
mądrzyć się: _: : imperf: subj{np(str)} + {cp(że)}
mądrzyć się: _: : imperf: subj{np(str)} + {or}
mądrzyć się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
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)}
mdlić: _: : imperf: {np(dat)} + {np(str)} + {preplexnp(na,acc,sg,'myśl',atr)}
mdlić: _: : imperf: {np(dat)} + {np(str)} + {preplexnp(na,acc,sg,'widok',atr)}
mdlić: _: : imperf: {np(dat)} + {np(str)} + {prepnp(od,gen)}
mdlić: _: : imperf: {np(dat)} + {np(str)} + {prepnp(z,gen)}
mdlić: _: : imperf: subj{np(str)} + {np(str)}
meandrować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
meandrować: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
meandrować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
meczeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
meczeć: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
merdać: _: : imperf: subj{np(str)} + {np(inst)} + {comprepnp(z powodu)}
merdać: _: : imperf: subj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'widok',atr)}
merdać: _: : imperf: subj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'znak',atr)}
merdać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
merdać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
merdać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
merdać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
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)}
mędrkować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
mędrkować: _: : imperf: subj{np(str)} + {cp(int)}
mędrkować: _: : imperf: subj{np(str)} + {cp(jak)}
mędrkować: _: : imperf: subj{np(str)} + {cp(że)}
mędrkować: _: : imperf: subj{np(str)} + {cp(żeby)}
mędrkować: _: : imperf: subj{np(str)} + {or}
mędrkować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
mętnieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',natr)}
mętnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
mętnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
mętnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
mętnieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
mętnieć: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
miarkować się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
miarkować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)}
miarkować się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int)}
miarkować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
miarkować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
miarkować: _: : imperf: subj{np(str)} + obj{np(str)}
miarkować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
miarkować: _: : imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
miarkować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
miarkować: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
miauczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
miauczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
miauczeć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
miauczeć: _: : imperf: subj{np(str)} + {np(dat)} + {nonch}
miauczeć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
miauczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
miauczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {nonch}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
miauczeć: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
miauknąć: _: : perf: subj{np(str)} + {cp(int)}
miauknąć: _: : perf: subj{np(str)} + {cp(że)}
miauknąć: _: : perf: subj{np(str)} + {cp(żeby)}
miauknąć: _: : perf: subj{np(str)} + {nonch}
miauknąć: _: : perf: subj{np(str)} + {or}
miauknąć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
miauknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
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}
mielić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,loc)}
mielić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(w,loc)}
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)}
mierzić: _: : imperf: subj{cp(gdy)} + {np(str)}
mierzić: _: : imperf: subj{cp(int)} + {np(str)}
mierzić: _: : imperf: subj{cp(jak)} + {np(str)}
mierzić: _: : imperf: subj{cp(jeśli)} + {np(str)}
mierzić: _: : imperf: subj{cp(kiedy)} + {np(str)}
mierzić: _: : imperf: subj{cp(że)} + {np(str)}
mierzić: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
mierzić: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
mierzwić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
mierzwić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
mierzwić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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}
miesiączkować: _: : imperf: subj{np(str)} + {xp(dur)}
miesiączkować: _: : imperf: subj{np(str)} + {xp(mod)}
miesić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
miesić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
miesić: _: : imperf: subj{np(str)} + {xp(locat)} + {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ędlić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
międlić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
międlić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
miętosić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
miętosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
miętosić: _: : imperf: subj{np(str)} + obj{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)}
migrować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
minuta: : : : {np(gen)}
minuta: : : : {np(gen)} + {possp} + {prepnp(dla,gen)} + {prepnp(do,gen); prepnp(na,acc); cp(żeby); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
minuta: : : : {np(gen)} + {prepnp(dla,gen)} + {prepnp(za,acc); prepncp(za,acc,że)} + {xp(locat)}
minuta: : : : {np(gen)} + {prepnp(po,loc); prepnp(przed,inst)}
minuta: : : : {possp} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)}
minuta: : : : {possp} + {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)}
mitologizować: _: : imperf: subj{np(str)} + obj{np(str)}
mitrężyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
mitygować: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
mitygować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
mitygować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
mitygować: _: : imperf: subj{np(str)} + {or}
mitygować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
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)}
mlaskać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
mlaskać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
mlaskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
mlaskać: _: : imperf: subj{np(str)} + {or}
mlasnąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
mlasnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
mlasnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
mlasnąć: _: : perf: subj{np(str)} + {or}
mleć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
mleć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mleć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
mleć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
młody: : : : {np(inst)}
młody: : : : {prepnp(o,acc)}
młócić się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
młócić: _: : imperf: subj{np(str)} + {cp(że)}
młócić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
młócić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
młócić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
młócić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
młócić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
młócić: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
młócić: _: : imperf: subj{np(str)} + {prepnp(w,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)}
modernizować się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,inst)} + {xp(mod)}
modernizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)} + {xp(mod)}
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)}
moknąć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
moknąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
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)}
monitować: _: : imperf: subj{np(str)} + {cp(int)}
monitować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
monitować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'kąt',ratr)}
monitować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
monitować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,inst,sg,'pomoc',ratr)}
monopolizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {lexnp(dat,_,'siebie',natr)}
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)}
morzyć: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
morzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
motać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
motać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
motać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
motać: _: : imperf: subj{np(str)} + {np(inst)}
motać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
motać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
motać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
motać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
motać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
motać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,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}
mozolić się: _: : imperf: subj{np(str)} + {cp(żeby)}
mozolić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
mozolić się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
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)}
mówić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
mówić: _: : imperf: subj{ncp(str,int)} + {prepnp(o,loc)} + {nonch}
mówić: _: : imperf: subj{ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
mówić: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {cp(że)}
mówić: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{np(nom)}
mówić: _: : imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
mówić: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{np(nom)}
mówić: _: : imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
mówić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
mówić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {ncp(str,że)}
mówić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
mówić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
mówić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
mówić: _: : imperf: subj{np(str)} + obj{or} + {np(dat)} + {prepnp(o,loc)}
mówić: _: : imperf: subj{np(str)} + obj{prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
mówić: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
mówić: _: : imperf: subj{np(str)} + {preplexnp(za,acc,_,'siebie',natr)}
mówić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
mówić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
mówić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); or}
mówić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {cp(że)}
mówić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {or}
mówić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
mówić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {prepnp(z,inst)}
mówić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
mrocznieć: _: : perf: subj{np(str)} + {np(inst)}
mrocznieć: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
mrocznieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
mroczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
mroczyć się: _: : imperf: subj{np(str)} + {np(inst)}
mroczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
mroczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mrowić się: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
mrowić się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
mrowić się: _: : imperf: subj{np(str)} + {xp(locat)}
mrowić: _: : imperf: {np(str)} + {xp(locat)}
mrowić: _: : 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}
mrużyć się: _: : imperf: subj{lexnp(str,_,'oko',atr)} + {np(dat)} + {prepnp(z,gen)}
mrużyć się: _: : imperf: subj{lexnp(str,_,'oko',atr)} + {prepnp(od,gen)}
mrużyć się: _: : imperf: subj{lexnp(str,_,'oko',atr)} + {prepnp(pod,inst)}
mrużyć się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
mrużyć się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
mrużyć: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'oko',atr)} + {prepnp(od,gen)}
mrużyć: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'oko',atr)} + {prepnp(pod,inst)}
mrużyć: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'oko',atr)} + {prepnp(w,loc)}
mrużyć: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'oko',atr)} + {prepnp(z,gen)}
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)}
mumifikować się: _: : imperf: subj{np(str)}
mumifikować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
mumifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mumifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
mumifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
mumifikować: _: : imperf: subj{np(str)} + {refl}
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)}
mutować się: _: : imperf: subj{np(str)}
mutować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
mutować: _: : imperf: subj{np(str)} + obj{np(str)}
mutować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
mutować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
mydlić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {lexnp(str,pl,'oko',natr)}
mydlić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
mydlić: _: : 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)}
myszkować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
myszkować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
myszkować: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(locat)}
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}
mżyć: _: : imperf: subj{E} + {prepnp(z,gen)}
mżyć: _: : imperf: subj{E} + {xp(locat)}
mżyć: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
mżyć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
mżyć: _: : imperf: subj{np(str)} + {xp(locat)}
nabawiać się: _: : imperf: subj{np(str)} + {np(gen)}
nabawiać: _: : imperf: subj{np(str)} + {np(gen)} + {np(str)}
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)}
nabiec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
nabiec: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nabiedzić się: _: : perf: subj{np(str)} + {cp(żeby)}
nabiedzić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
nabiegać się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
nabiegać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nabiegać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
nabiegać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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}
nabrudzić się: _: : perf: {np(inst)} + {xp(locat)}
nabrudzić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
nabrudzić: _: : perf: subj{np(str)} + {xp(adl)}
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)}
naburmuszyć się: _: : perf: subj{np(str)} + {or}
naburmuszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
naburmuszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
naburmuszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
nachapać się: _: : perf: subj{np(str)} + {np(gen)}
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)}
nacierpieć się: _: : perf: subj{np(str)}
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)}
naczerpać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
naczerpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
naczytać się: _: : perf: subj{np(str)} + {np(dat)}
naczytać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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ąć się: _: : perf: subj{np(str)} + {np(inst)}
nadąć się: _: : perf: subj{np(str)} + {xp(mod)}
nadąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nadąsać się: _: : perf: subj{np(str)} + {or}
nadąsać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
nadąsać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nadąsać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
nadbudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nadbudować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
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)}
nadlatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
nadlatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
nadlatywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
nadlecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nadlecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
nadlecieć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
nadlecieć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
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)}
nadpisać: _: : perf: subj{np(str)} + obj{np(str)}
nadpisywać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
nadpłynąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadpływać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadpsuć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
nadpsuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
nadsłuchiwać: _: : imperf: subj{np(str)} + {cp(int)}
nadsłuchiwać: _: : imperf: subj{np(str)} + {cp(jak)}
nadsłuchiwać: _: : imperf: subj{np(str)} + {np(gen)}
nadstawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
nadstawiać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
nadstawić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
nadstawić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
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)}
nadwerężać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
nadwerężać się: _: : imperf: subj{np(str)} + {np(inst)}
nadwerężać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadwerężyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
nadwerężyć się: _: : perf: subj{np(str)} + {np(inst)}
nadwerężyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadwrażliwy: : : : {preplexnp(na,loc,sg,'punkt',atr)}
nadwrażliwy: : : : {prepnp(na,acc)}
nadwyrężać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
nadwyrężać się: _: : imperf: subj{np(str)} + {np(inst)}
nadwyrężać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadwyrężyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
nadwyrężyć się: _: : perf: subj{np(str)} + {np(inst)}
nadwyrężyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadymać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
nadymać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
nadziać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nadziać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nadziać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nadziać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
nadziewać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nadziewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nadziewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
naelektryzować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
naelektryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
naglić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
naglić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
naglić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
naglić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
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)}
nagotować: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
nagotować: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(dla,gen)}
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)}
nagromadzać się: _: : imperf: {np(dat)} + {np(gen)} + {xp(locat)}
nagromadzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
nagromadzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
nagromadzić się: _: : perf: {np(dat)} + {np(part)} + {xp(locat)}
nagromadzić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
nagromadzić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
nagromadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
nagryzmolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {cp(int)}
nagryzmolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
nagryzmolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {cp(żeby)}
nagryzmolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {or}
nagryzmolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
nagryzmolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)} + {prepadjp(po,postp)}
nagryzmolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
nagrzać się: _: : perf: subj{np(str)} + {np(inst)}
nagrzać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(mod)}
nagrzać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
nagrzać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
nagrzać się: _: : perf: subj{np(str)} + {xp(locat)}
nagrzać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
nagrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
nagrzeszyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
nagrzeszyć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
nagrzeszyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
nagrzewać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
nagrzewać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
nagrzewać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
nagrzewać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {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)}
naigrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
naigrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
naigrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
naigrywać 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)}
nająć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(w,loc,sg,'charakter',atr)}
nająć się: _: : perf: subj{np(str)} + {prepnp(jako,str)}
nająć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
nająć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(za,acc)}
nająć się: _: : perf: subj{np(str)} + {xp(locat)}
nająć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
nająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {preplexnp(w,loc,sg,'charakter',atr)}
nająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
nająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
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ździć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
najeździć się: _: : perf: subj{np(str)} + {np(inst)}
najeździć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
najeździć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
najeździć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
najeździć się: _: : perf: subj{np(str)} + {xp(locat)}
najeździć się: _: : perf: subj{np(str)} + {xp(perl)}
najeździć: _: : 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)}
najmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(jako,str)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(u,gen)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {xp(locat)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(jako,str)} + {prepnp(u,gen)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(jako,str)} + {prepnp(za,acc)} + {xp(locat)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)} + {xp(locat)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(za,acc)} + {prepnp(za,acc)}
najmować się: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {prepnp(za,acc)} + {xp(locat)}
najmować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(za,acc)}
najmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(za,acc)}
najmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
najmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)} + {prepnp(za,acc)}
najmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {prepnp(za,acc)}
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)}
nakleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nakleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
naklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
naklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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łamać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
nakłamać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nakłamać: _: : perf: subj{np(str)} + {np(dat)} + {nonch}
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)}
nakraść się: _: : perf: subj{np(str)} + {np(gen)}
nakraść: _: : perf: subj{np(str)} + {np(dat)} + {np(part)}
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)}
nakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
nakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {nonch}
nakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
nakrzyczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nakupić: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
nakupić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)}
nakupić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
nakupić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(za,acc)}
nakupić: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
nakupować: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
nakupować: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)}
nakupować: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
nakupować: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(za,acc)}
nakupować: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
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)}
nalatać się: _: : perf: subj{np(str)} + {np(inst)}
nalatać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
nalatać się: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
nalatać się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
nalatać się: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
nalatać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
nalatać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nalatać: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
nalatać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,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)}
nalepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nalepiać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(na,acc)}
nalepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
nalepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nalepić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
nalepić: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(na,acc)}
nalepić: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {prepnp(z,gen)}
nalepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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łazić się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
nałazić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nałazić się: _: : perf: subj{np(str)} + {xp(locat)}
nałazić się: _: : perf: subj{np(str)} + {xp(perl)}
nałazić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,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)}
nałykać się: _: : perf: subj{np(str)} + {np(gen)}
namacać: _: : perf: subj{np(str)} + {np(gen)}
namacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
namakać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
namakać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
namakać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
namalować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {prepnp(na,loc)} + {refl}
namalować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
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}
namęczyć się: _: : perf: subj{np(str)} + {cp(żeby)}
namęczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,żeby)}
namęczyć się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
namęczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
namęczyć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
namierzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
namierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
namierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
namierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
namierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
namierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
namierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
namierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
namnażać się: _: : imperf: {np(gen)} + {xp(locat)}
namnażać się: _: : imperf: subj{np(str)} + {xp(locat)}
namnażać: _: : imperf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
namnażać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
namnożyć się: _: : perf: {np(gen)}
namnożyć się: _: : perf: subj{np(str)}
namnożyć: _: : perf: subj{np(str)} + obj{np(gen)}
namnożyć: _: : perf: subj{np(str)} + obj{np(str)}
namoczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
namoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
namoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
namoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
namoczyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
namoknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
namoknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
namoknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
namordować się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
namordować się: _: : perf: subj{np(str)} + {prepnp(podczas,gen)}
namordować się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
namordować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
namordować: _: : perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
namordować: _: : perf: subj{np(str)} + obj{np(gen)} + {prepnp(z,gen)}
namordować: _: : perf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
namotać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
namotać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
namotać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
namotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
namotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
namozolić się: _: : perf: subj{np(str)} + {cp(żeby)}
namozolić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,żeby)}
namozolić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
namozolić się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
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)}
namydlić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
namydlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
naobiecywać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
naobiecywać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
naobiecywać: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
naobiecywać: _: : perf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,że)}
naobiecywać: _: : perf: subj{np(str)} + {np(dat)} + {or}
naoliwić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
naoliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
naopowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
naopowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
naopowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
naopowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
naopowiadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
naopowiadać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
naopowiadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
naopowiadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
naopowiadać: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
naopowiadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
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)}
napalić się: _: : perf: subj{np(str)} + {cp(żeby)}
napalić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
napalić się: _: : perf: subj{np(str)} + {xp(mod)}
napalić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
napalić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
napalić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
naparzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
naparzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
naparzać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
naparzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
naparzyć się: _: : perf: subj{np(str)} + {np(gen)}
naparzyć się: _: : perf: subj{np(str)} + {xp(locat)}
naparzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
naparzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
napastować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
napastować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
napastować: _: : imperf: subj{np(str)} + obj{np(str)} + {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}
napatoczyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
napatoczyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
napatoczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
napatrzeć się: _: : perf: subj{np(str)} + {cp(int)}
napatrzeć się: _: : perf: subj{np(str)} + {cp(jak)}
napatrzeć się: _: : perf: subj{np(str)} + {cp(że)}
napatrzeć się: _: : perf: subj{np(str)} + {np(dat)}
napatrzeć się: _: : perf: subj{np(str)} + {np(gen)}
napatrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że)}
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ęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
napęcznieć: _: : perf: subj{np(str)} + {np(inst)}
napęcznieć: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
napęcznieć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
napęcznieć: _: : perf: subj{np(str)} + {prepnp(wskutek,gen)}
napęcznieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
napiętnować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
napiętnować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
napiętnować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
napiętnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
napiętnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
napluć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
napluć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
napluć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
napłakać się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
napłakać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
napłakać się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
napłakać się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
napłakać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
napłakać: _: : perf: subj{np(str)} + {np(str)}
napłakać: _: : perf: subj{np(str)} + {xp(adl)}
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)}
napocić się: _: : perf: subj{np(str)} + {cp(żeby)}
napocić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
napocić się: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,żeby)}
napocząć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napoczynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napoić się: _: : perf: subj{np(str)} + {np(inst)}
napoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napominać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
napominać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
napominać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
napominać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
napominać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
napomknąć: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
napomknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
napomknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
napomknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
napomknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
napomknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
napomknąć: _: : 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)} + {nonch}
napomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
napomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
napomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
napomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
napomnieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
napomykać: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
napomykać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
napomykać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
napomykać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
napomykać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
napomykać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
napomykać: _: : 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)} + {nonch}
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)}
napowietrzać się: _: : imperf: subj{np(str)}
napowietrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
napraszać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
napraszać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
napraszać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
napraszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
napraszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
napraszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
napraszać się: _: : imperf: subj{np(str)} + {np(gen)}
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)}
napromieniować się: _: : perf: subj{np(str)} + {np(inst)}
napromieniować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
naprosić się: _: : perf: subj{np(str)} + {np(gen)} + {or}
naprosić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
naprosić się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
naprosić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
naprosić: _: : perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
naprostować: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
napsocić: _: : perf: subj{np(str)} + obj{adjp(str)}
napsocić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
napsocić: _: : perf: subj{np(str)} + {prepnp(z,inst)}
napsuć się: _: : perf: subj{np(str)}
napsuć: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {np(inst)}
napuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
napuszać się: _: : imperf: subj{np(str)}
napuszać: _: : imperf: subj{np(str)} + obj{np(str)}
napuszczać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(po,acc)} + {xp(adl)}
napuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
napuszyć się: _: : perf: subj{np(str)}
napuszyć: _: : perf: subj{np(str)} + obj{np(str)}
napuścić: _: : perf: subj{np(str)} + {np(part)} + {prepnp(do,gen)}
napuścić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(po,acc)}
napuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
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)}
napytać: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
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)}
naradzić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)} + {prepnp(z,inst)}
naradzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
naradzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
naradzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
naradzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
naradzić się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {or}
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)}
narobić się: _: : perf: {np(dat)} + {np(gen)}
narobić się: _: : perf: {np(gen)} + {xp(locat)}
narobić się: _: : perf: {prepnp(z,inst)}
narobić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
narobić się: _: : perf: subj{np(str)} + {np(gen)}
narobić się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
narobić się: _: : perf: subj{np(str)} + {prepnp(po,acc)}
narobić się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
narobić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
narobić się: _: : perf: subj{np(str)} + {xp(locat)}
narobić: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {comprepnp(z powodu)}
narobić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
narobić: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
narobić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(dla,gen)}
narobić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
narobić: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(z,inst)}
narobić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
narobić: _: : perf: subj{np(str)} + {xp(adl)}
narobić: _: : perf: subj{np(str)} + {xp(locat)}
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)}
narozrabiać: _: : perf: subj{np(str)} + {nonch}
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)}
nasiać: _: : perf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
nasiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(mod)}
nasiąkać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(mod)}
nasiąknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(mod)}
nasiąknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(mod)}
nasiedzieć się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
nasiedzieć się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
nasiedzieć się: _: : perf: subj{np(str)} + {xp(locat)}
nasikać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
nasikać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasikać: _: : perf: subj{np(str)} + {xp(locat)}
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)}
naskarżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
naskarżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
naskarżyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int)}
naskarżyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
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)}
naskoczyć: _: : perf: subj{np(str)} + {np(dat)}
naskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
naskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
naskoczyć: _: : perf: subj{np(str)} + {xp(adl)}
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)}
nasmarować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
nasmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nasolić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
nasrożyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nasrożyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
nasrożyć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
nastraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
nastraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
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)}
naszkicować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(locat)}
naszpikować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
naszpikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
naszukać się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
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)}
naszykować się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
naszykować: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
naszykować: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
naszykować: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
naszykować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
naszykować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
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śmiać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
naśmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {advp(misc)}
naśmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
naśmiać się: _: : perf: subj{np(str)} + {xp(mod)}
naśmiecić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
naświetlać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
naświetlać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
naświetlać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
naświetlać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
naświetlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
naświetlić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
naświetlić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
naświetlić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
naświetlić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
naświetlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
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)}
natłuszczać się: _: : imperf: subj{np(str)}
natłuszczać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
natłuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
natłuścić się: _: : perf: subj{np(str)}
natłuścić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
natłuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
natrafiać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrafić: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrudzić się: _: : perf: subj{np(str)} + {comprepnp(na rzecz)}
natrudzić się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
natrudzić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
natrudzić się: _: : perf: subj{np(str)} + {cp(żeby)}
natrudzić się: _: : perf: subj{np(str)} + {np(inst)}
natrudzić się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
natrudzić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
natrudzić się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
natrząsać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
natrząsać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
natrząsać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(jak)}
natrząsać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
natrząsać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
natrząsać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,ż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)}
naturalizować się: _: : _: subj{np(str)} + {xp(locat)}
naturalizować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
natykać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby2)}
naubliżać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
naubliżać: _: : perf: subj{np(str)} + {np(dat)} + {or}
naubliżać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
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)}
naurągać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
naurągać: _: : perf: subj{np(str)} + {np(dat)} + {or}
naurągać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
nawarzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
nawarzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
nawarzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(z,gen)}
nawarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
nawarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
nawieźć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nawieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nawieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
nawigować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
nawigować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
nawigować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(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)}
nawrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nawrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nawrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
nawrzeszczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nawrzucać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nawrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nawrzucać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
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)}
nawymyślać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
nawymyślać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
nawymyślać: _: : perf: subj{np(str)} + {np(dat)} + {or}
nawymyślać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
nawymyślać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nawymyślać: _: : perf: subj{np(str)} + {np(gen)}
nawymyślać: _: : perf: subj{np(str)} + obj{np(str)}
nawymyślać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
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)}
nazjeżdżać się: _: : perf: {np(gen)} + {xp(abl)} + {xp(adl)}
nazjeżdżać się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)}
nazjeżdżać się: _: : perf: subj{np(str)} + {xp(adl)}
nazjeżdżać: _: : perf: {np(gen)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nazjeżdżać: _: : perf: {np(gen)} + {prepnp(na,loc)} + {xp(abl)} + {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)}
naznosić: _: : perf: subj{np(str)} + obj{cp(int)}
naznosić: _: : perf: subj{np(str)} + obj{np(part)} + {cp(żeby)}
naznosić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
naznosić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
naznosić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
naznosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
naznosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nazrywać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(dla,gen)}
nazrywać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
nazrywać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(locat)}
nazrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
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)}
nażreć się: _: : perf: subj{np(str)} + {np(gen)}
nażreć się: _: : perf: subj{np(str)} + {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ęcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nęcić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
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)}
niańczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
nicować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
nicować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nicować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nicować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'strona',ratr)}
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)}
niecić się: _: : imperf: subj{np(str)}
niecić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
niecić: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
niemczyć się: _: : imperf: subj{np(str)}
niemczyć: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
nieruchomieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
nieruchomieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
nieruchomieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
nieruchomieć: _: : imperf: subj{np(str)} + {xp(dur)}
nieruchomieć: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
niewolić się: _: : imperf: subj{np(str)} + {np(inst)}
niewolić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
niklować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
nobilitować: _: : _: subj{np(str)} + {np(inst)} + {refl}
nobilitować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
nobilitować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nobilitować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nobilitować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
nobilitować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
nobilitować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
nobilitować: _: : _: subj{np(str)} + {prepnp(na,acc)} + {refl}
nocować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nocować: _: : imperf: subj{np(str)} + {xp(locat)} + {preplexnp(na,acc,sg,'walet',natr)}
nokautować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
nokautować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
normalizować się: _: : imperf: subj{np(str)} + {np(dat)}
normalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(co do)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
notyfikować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jakoby)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
notyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
nurkować: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
nurkować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
nurkować: _: : imperf: subj{np(str)} + {xp(abl)}
nurkować: _: : imperf: subj{np(str)} + {xp(adl)}
nurkować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
nurzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
nurzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
nużyć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
nużyć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
nużyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
obałamucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
obcałować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
obcałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obcałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obcałować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
obcałować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obcałowywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
obcałowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obcałowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obcałowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
obcałowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
obciskać się: _: : imperf: subj{np(str)} + {xp(locat)}
obciskać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
obdrapać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
obdrapać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
obgadać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
obgadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {cp(int)}
obgadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {cp(że)}
obgadać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obgadywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
obgadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {cp(int)}
obgadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {cp(że)}
obgadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
obiektywizować się: _: : imperf: subj{np(str)}
obiektywizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obielić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
obkleić się: _: : perf: subj{np(str)} + {xp(locat)}
obkleić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obkleić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obklejać się: _: : imperf: subj{np(str)} + {xp(locat)}
obklejać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
oblatać się: _: : perf: subj{np(str)}
oblatać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
oblatywać się: _: : imperf: subj{np(str)}
oblatywać: _: : imperf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(gdy)}
oblatywać: _: : imperf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(jak)}
oblatywać: _: : imperf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(kiedy)}
oblatywać: _: : imperf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(że)}
oblatywać: _: : imperf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(żeby)}
oblatywać: _: : imperf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {prepnp(o,acc)}
oblatywać: _: : imperf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {prepnp(przed,inst)}
oblatywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oblatywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oblatywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
oblatywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
oblatywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
oblec: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
oblec: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oblec: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
oblec: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oblec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
oblec: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
oblecieć: _: : perf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(gdy)}
oblecieć: _: : perf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(jak)}
oblecieć: _: : perf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(kiedy)}
oblecieć: _: : perf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {cp(że)}
oblecieć: _: : perf: subj{lexnp(str,sg,'strach',natr)} + {np(str)} + {prepnp(o,acc)}
oblecieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oblecieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oblecieć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
oblegać: _: : imperf: subj{np(str)} + obj{np(str)}
oblekać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
oblekać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oblekać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
oblekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oblekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
oblekać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
obleźć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obleźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
oblizać się: _: : perf: subj{np(str)} + {xp(mod)}
oblizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblizywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
oblizywać się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'myśl',atr)}
oblizywać się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'widok',atr)}
oblizywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
oblizywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
oblizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
oblizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oblizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
oblizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oblizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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łamać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
obłamać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
obłamać się: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
obłamać się: _: : perf: subj{np(str)} + {xp(adl)}
obłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
obłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
obłamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
obłamywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
obłamywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
obłamywać się: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
obłamywać się: _: : imperf: subj{np(str)} + {xp(adl)}
obłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
obłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
obłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
obłapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obłapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
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łazić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obłazić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obłocić: _: : perf: subj{np(str)} + {np(dat)} + {refl}
obłocić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
obmawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
obmawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
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)}
obmówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
obmówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
obmurować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obmurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obmyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obmyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obmyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
obmyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)} + {refl}
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)}
obmywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
obmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
obmywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
obmywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)} + {refl}
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)}
obrabowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obrabowywać: _: : imperf: 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)}
obramować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obramować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
obrodzić się: _: : perf: subj{np(str)}
obrodzić: _: : perf: {np(inst)} + {xp(locat)}
obrodzić: _: : perf: {prepnp(w,acc)} + {xp(locat)}
obrodzić: _: : perf: subj{np(str)} + {np(inst)}
obrodzić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
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)}
obryzgać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obryzgać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obryzgiwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obryzgiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
obrzeżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrzęknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
obrzęknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
obrzęknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
obrzęknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
obrzydnąć: _: : perf: subj,controllee{infp(imperf)} + controller{np(dat)}
obrzydnąć: _: : perf: subj{cp(int)} + {np(dat)}
obrzydnąć: _: : perf: subj{cp(że)} + {np(dat)}
obrzydnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
obrzydzać się: _: : imperf: subj{np(str)} + {np(dat)}
obrzydzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
obrzydzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
obrzydzać: _: : imperf: subj{cp(gdy)} + {np(str)}
obrzydzać: _: : imperf: subj{cp(int)} + {np(str)}
obrzydzać: _: : imperf: subj{cp(jak)} + {np(str)}
obrzydzać: _: : imperf: subj{cp(kiedy)} + {np(str)}
obrzydzać: _: : imperf: subj{cp(że)} + {np(str)}
obrzydzać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + obj{np(str)} + {np(dat)}
obrzydzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
obrzydzić się: _: : perf: subj{np(str)} + {np(dat)}
obrzydzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
obrzydzić: _: : perf: subj{cp(gdy)} + {np(str)}
obrzydzić: _: : perf: subj{cp(int)} + {np(str)}
obrzydzić: _: : perf: subj{cp(jak)} + {np(str)}
obrzydzić: _: : perf: subj{cp(kiedy)} + {np(str)}
obrzydzić: _: : perf: subj{cp(że)} + {np(str)}
obrzydzić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + obj{np(str)} + {np(dat)}
obrzydzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
obskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
obskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
obskoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {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}
obsmarować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
obsmarować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
obsmarować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
obsmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsmarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
obsmarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
obsmarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obsmarowywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obsmarowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
obsmarowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
obsmarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsmarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
obsmarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
obsmarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obsmażyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
obsmażyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
obsmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obsmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
obstąpić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(locat)}
obstępować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(abl)}
obstępować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(locat)}
obstępować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obstukać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
obstukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
obstukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obstukać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
obstukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obstukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obstukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obstukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
obszczekiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
obszczekiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obszukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obszukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
obściskiwać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
obściskiwać: _: : imperf: subj{np(str)} + obj{np(str)}
obśmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
obśmiać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obśmiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
obśmiewać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obśmiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
obtaczać się: _: : imperf: subj{np(str)} + {np(inst)}
obtaczać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
obtaczać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
obtaczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
obtaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obtaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obtaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obtłuc się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obtłuc się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
obtłuc się: _: : perf: subj{np(str)} + {xp(locat)}
obtłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obtłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obtłukiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obtłukiwać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
obtłukiwać się: _: : imperf: subj{np(str)} + {xp(locat)}
obtłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obtłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
obtoczyć się: _: : perf: subj{np(str)} + {np(inst)}
obtoczyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
obtoczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
obtoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obtoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obtoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
oburknąć się: _: : perf: subj{np(str)} + {cp(że)}
oburknąć się: _: : perf: subj{np(str)} + {or}
oburknąć: _: : perf: subj{np(str)} + obj{np(str)}
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}
obwarować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
obwarować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
obwarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
obwarowywać się: _: : imperf: subj{np(str)} + {np(inst)}
obwarowywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
obwarowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
obwarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obwąchać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
obwąchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obwąchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
obwąchiwać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
obwąchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obwąchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obwąchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
obwiązać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
obwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
obwiązywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
obwiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
obwieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obwieźć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
obwieźć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(perl)}
obwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
obwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(perl)}
obwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
obwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
obwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
obwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {xp(perl)}
obwijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
obwijać się: _: : imperf: subj{np(str)} + {xp(locat)}
obwijać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
obwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
obwijać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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}
obwisać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
obwisać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
obwisać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
obwisać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
obwisnąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
obwisnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
obwisnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
obwisnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
obwołać: _: : perf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
obwołać: _: : perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
obwołać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
obwołać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
obwoływać: _: : imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
obwoływać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
obwoływać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
obwoływać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
obwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
obwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
obwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
obwozić: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)} + {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żerać się: _: : imperf: subj{np(str)} + {np(gen)}
obżerać się: _: : imperf: subj{np(str)} + {np(inst)}
obżerać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
obżerać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
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łodnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
ochłodnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ochłodnąć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
ochłodnąć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
ochrypnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ochrypnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
ocieplać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
ocieplać się: _: : imperf: {xp(locat)}
ocieplać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ocieplić się: _: : perf: {prepnp(do,gen)} + {xp(locat)}
ocieplić się: _: : perf: {prepnp(o,acc)} + {xp(locat)}
ocieplić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
ocieplić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
ocieplić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocieplić: _: : perf: subj{np(str)} + obj{np(str)} + {np(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)}
oclić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
oclić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocucić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ocucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ocyganić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
ocyganić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ocynkować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
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)}
oczarowywać się: _: : imperf: subj{np(str)}
oczarowywać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
oczarowywać: _: : imperf: 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)}
odbarwiać się: _: : imperf: subj{np(str)} + {np(dat)}
odbarwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odbarwić się: _: : perf: subj{np(str)} + {np(dat)}
odbarwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
odbębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odbębniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odbębnić: _: : perf: subj{np(str)} + obj{np(str)}
odbębnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
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)}
odbiurokratyzować się: _: : perf: subj{np(str)}
odbiurokratyzować: _: : perf: subj{np(str)} + obj{np(str)}
odblokować się: _: : perf: subj{np(str)} + {advp(misc)}
odblokować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
odblokować się: _: : perf: subj{np(str)} + {xp(locat)}
odblokować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odblokowywać się: _: : imperf: subj{np(str)} + {advp(misc)}
odblokowywać się: _: : imperf: subj{np(str)} + {np(dat)}
odblokowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
odblokowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odblokowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
odblokowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odblokowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
odburkiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odburkiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odburkiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {nonch}
odburkiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odburknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odburknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odburknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {nonch}
odburknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
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)}
odcedzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odcedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odcedzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
odchorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odchorować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odchorowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odchorowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
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)}
odchrząknąć: _: : perf: subj{np(str)} + obj{np(str)}
odchudzać się: _: : imperf: subj{np(str)} + {np(dat)}
odchudzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
odchudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odchudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odchudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odchudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odchudzać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
odchudzać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
odchudzić się: _: : perf: subj{np(str)} + {np(dat)}
odchudzić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
odchudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odchudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odchudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odchudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odchudzić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
odchudzić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
odciążać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odciążać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odciążać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odciążać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odciążać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
odciążyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
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)}
odcyfrować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odcyfrować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odcyfrować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
odcyfrowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odcyfrowywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odcyfrowywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
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ż)}
odczekiwać: _: : imperf: 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)}
odczłowieczyć się: _: : perf: subj{np(str)}
odczłowieczyć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
odczulać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
odczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
odczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
odczulać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
odczulać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
odczulać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {refl}
odczulać: _: : imperf: subj{np(str)} + {xp(mod)} + {refl}
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)}
oddelegować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
oddelegować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oddelegować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
oddelegować: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
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)}
oddzierać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
oddzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oddzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oddzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oddzierać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,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)}
odedrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odedrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,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)}
odemknąć się: _: : perf: subj{np(str)}
odemknąć: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
odemknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
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)}
oderżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oderżnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
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)}
odespać się: _: : perf: subj{np(str)} + {xp(locat)}
odespać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
odfajkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {cp(że)}
odfajkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(że)}
odformalizować: _: : perf: subj{np(str)} + obj{np(str)}
odfrunąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odfrunąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
odfruwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)}
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)}
odgradzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odgradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odgraniczać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
odgraniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odgraniczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
odgraniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
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}
odgrodzić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odgrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odgruzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odgruzowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
odgrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odgrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
odgrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odgrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {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)}
odholować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odholować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
odholować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
odizolować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
odizolować: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)} + {refl}
odizolowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
odizolowywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
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)}
odjechać: _: : perf: subj{np(str)} + {np(inst)}
odjechać: _: : perf: subj{np(str)} + {xp(abl)}
odjechać: _: : perf: subj{np(str)} + {xp(adl)}
odjechać: _: : perf: subj{np(str)} + {xp(temp)}
odjeżdżać: _: : imperf: subj{np(str)} + {np(inst)}
odjeżdżać: _: : imperf: subj{np(str)} + {xp(abl)}
odjeżdżać: _: : imperf: subj{np(str)} + {xp(adl)}
odjeżdżać: _: : imperf: subj{np(str)} + {xp(temp)}
odkarmić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
odkarmić się: _: : perf: subj{np(str)} + {xp(locat)}
odkarmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odkarmić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odkarmić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odkaszlnąć: _: : perf: subj{np(str)} + {np(inst)}
odkaszlnąć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
odkleić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odkleić się: _: : perf: subj{np(str)} + {xp(abl)}
odkleić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odkleić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
odklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
odkłamać: _: : perf: subj{np(str)} + obj{np(str)}
odkłonić się: _: : perf: subj{np(str)} + {np(dat)}
odkochać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
odkodować: _: : perf: subj{np(str)} + obj{np(str)}
odkomenderować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odkomenderować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
odkupywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
odlać się: _: : perf: subj{np(str)} + {xp(locat)}
odlać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(z,gen)}
odlać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
odlepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
odlepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
odlepić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
odlepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
odlewać się: _: : imperf: subj{np(str)} + {xp(adl)}
odlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
odłupać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(od,gen)}
odłupać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(z,gen)}
odłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odłupywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(od,gen)}
odłupywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(z,gen)}
odłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odmalować się: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'twarz',ratr)}
odmalować się: _: : perf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',ratr)}
odmalować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)} + {xp(locat)}
odmalować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)} + {xp(locat)}
odmalować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odmalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odmalowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
odmalowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)} + {xp(locat)}
odmalowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)} + {np(dat)} + {xp(locat)}
odmalowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
odmalowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odmarzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odmarzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odmarznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odmarznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odmaszerować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
odmiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odmiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
odmieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {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)}
odmruknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
odmruknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odmruknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
odmruknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odmruknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odmruknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
odmruknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odmruknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
odmruknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
odmruknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
odmruknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
odmruknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
odmruknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
odmykać się: _: : imperf: subj{np(str)} + {np(inst)}
odmykać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
odmykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odnająć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odnająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
odnajdować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
odnajdować się: _: : imperf: subj{np(str)} + {xp(locat)}
odnajdować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
odnajdować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
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)}
odnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
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)}
odpakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpakować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
odpakowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpakowywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
odparzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odparzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
odparzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odparzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odparzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
odparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
odpełznąć: _: : perf: subj{np(str)} + {xp(adl)}
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}
odpieczętować: _: : perf: subj{np(str)} + obj{np(str)}
odpieprzyć się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odpieprzyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(z,inst)}
odpieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
odpiłować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odpiłowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odpinać się: _: : imperf: subj{np(str)} + {np(dat)}
odpinać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
odpinać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odpinać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
odpinać się: _: : imperf: subj{np(str)} + {xp(locat)}
odpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpinać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odpinać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
odpokutować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpokutować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
odpokutowywać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpokutowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
odpolitycznić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
odpracować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
odpracować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odpracować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
odpracowywać: _: : imperf: subj{np(str)} + {cp(żeby)}
odpracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odpracowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
odpruć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
odpruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odpruwać się: _: : imperf: subj{np(str)}
odpruwać się: _: : imperf: subj{np(str)} + {xp(locat)}
odpruwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
odpryskiwać się: _: : imperf: subj{np(str)} + {np(dat)}
odpryskiwać: _: : imperf: subj{np(str)} + {np(dat)}
odpryskiwać: _: : imperf: subj{np(str)} + {xp(abl)}
odpryskiwać: _: : imperf: subj{np(str)} + {xp(adl)}
odpryskiwać: _: : imperf: subj{np(str)} + {xp(locat)}
odprysnąć się: _: : perf: subj{np(str)} + {np(dat)}
odprysnąć: _: : perf: subj{np(str)} + {np(dat)}
odprysnąć: _: : perf: subj{np(str)} + {xp(abl)}
odprysnąć: _: : perf: subj{np(str)} + {xp(adl)}
odprysnąć: _: : perf: subj{np(str)} + {xp(locat)}
odprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'cena',atr)}
odprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,acc)}
odprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
odprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'cena',atr)}
odprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,acc)}
odprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
odprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
odraczać się: _: : imperf: subj{np(str)}
odraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
odraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(dur)}
odraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'wzgląd',ratr)}
odraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {preplexnp(z,gen,sg,'powodu',ratr)}
odraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
odraczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
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)}
odrastać: _: : imperf: subj{np(str)} + {np(dat)}
odrastać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odratować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odratować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odratować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odrąbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odrąbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odrąbywać: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
odremontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odremontować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
odrestaurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odrętwieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
odrętwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
odrętwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odrętwieć: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
odrobaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
odrodzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
odrodzić: _: : perf: subj{np(str)} + obj{np(str)}
odrosnąć: _: : perf: subj{np(str)} + {np(dat)}
odrosnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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)}
odrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odrysować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odrysować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odrysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odrysowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
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)}
odrzekać się: _: : imperf: subj{np(str)} + {np(gen)}
odrzekać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odrzekać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
odrzekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odrzekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odrzekać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
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)}
odrzynać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
odrzynać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odrzynać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
odrzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
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)}
odseparować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odseparować: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odseparowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odseparowywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odsiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsiadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odsiarczać: _: : imperf: subj{np(str)} + obj{np(str)}
odsiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odsiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
odskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
odskakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
odskakiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {prepnp(od,gen)}
odskakiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
odskakiwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
odskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)} + {prepnp(w,loc)}
odskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(w,loc)} + {prepnp(z,gen)}
odskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,loc)} + {prepnp(z,gen)}
odskoczyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
odskoczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {prepnp(od,gen)} + {prepnp(w,loc)}
odskoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {prepnp(w,loc)} + {prepnp(z,gen)}
odskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)} + {prepnp(w,loc)} + {prepnp(z,gen)}
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)}
odsprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
odsprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odsprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odsprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
odsprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odsprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odstać się: _: : perf: subj{np(str)}
odstać: _: : 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)}
odstręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
odstręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
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)}
odsypiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
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)}
odszczekać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
odszczekać się: _: : perf: subj{np(str)} + {np(dat)} + {or}
odszczekać: _: : perf: subj{np(str)} + {cp(że)}
odszczekać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
odszczekać: _: : perf: subj{np(str)} + {or}
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śnieżać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odśnieżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odśnieżyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
odtajać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odtajniać się: _: : imperf: subj{np(str)}
odtajniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odtajnić się: _: : perf: subj{np(str)}
odtajnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odtańczyć: _: : perf: subj{np(str)} + obj{np(str)}
odtłuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
odtransportować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)}
odtrąbić: _: : perf: subj{np(str)} + {cp(że)}
odtrąbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odtrąbić: _: : perf: subj{np(str)} + {or}
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)}
odtruć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odtruć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odtruwać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
odtruwać: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
oduczać się: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)}
oduczać się: _: : imperf: subj{np(str)} + {cp(że)}
oduczać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)} + {np(inst)}
oduczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
oduczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)}
oduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)} + {np(inst)}
oduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
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)}
odwalać: _: : imperf: {np(dat)} + {comprepnp(z powodu)}
odwalać: _: : imperf: {np(dat)} + {preplexnp(na,loc,sg,'punkt',atr)}
odwalać: _: : imperf: {np(dat)} + {prepnp(od,gen)}
odwalać: _: : imperf: {np(dat)} + {prepnp(z,gen)}
odwalać: _: : imperf: subj{np(str)} + {lexnp(str,sg,'kita',natr)}
odwalać: _: : imperf: subj{np(str)} + {np(dat)}
odwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
odwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odwalić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
odwalić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
odwalić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
odwalić: _: : perf: {np(dat)} + {comprepnp(z powodu)}
odwalić: _: : perf: {np(dat)} + {preplexnp(na,loc,sg,'punkt',atr)}
odwalić: _: : perf: {np(dat)} + {prepnp(od,gen)}
odwalić: _: : perf: {np(dat)} + {prepnp(z,gen)}
odwalić: _: : perf: subj{np(str)} + {lexnp(str,sg,'kita',natr)}
odwalić: _: : perf: subj{np(str)} + {np(dat)}
odwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odwalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
odwalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odwalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odwarknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
odwarknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odwarknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odwarknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
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)}
odwiązać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odwiązać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odwiązywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odwiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odwiązywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
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}
odwirować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odwirować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
odwzorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odwzorować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odwzorować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odwzorować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odwzorowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odwzorowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
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)}
odzwyczaić: _: : perf: subj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)} + {refl}
odzwyczaić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {refl}
odzwyczaić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)}
odzwyczaić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
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żałować: _: : perf: subj{np(str)} + {cp(że)}
odżałować: _: : perf: subj{np(str)} + {np(str); ncp(str,że)}
odżałować: _: : perf: subj{np(str)} + {np(str)} + {prepnp(dla,gen)}
odżałować: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
odżegnać się: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,jakoby); prepncp(od,gen,że); prepncp(od,gen,żeby)}
odżegnywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,jakoby); prepncp(od,gen,że); prepncp(od,gen,żeby)}
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)}
odżywić się: _: : perf: subj{np(str)} + {np(inst)}
odżywić: _: : perf: 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)}
oganiać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
oganiać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
oganiać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
oganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
oganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
oganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
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}
oglądnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
oglądnąć się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
oglądnąć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w roli)}
oglądnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
oglądnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jak)}
oglądnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
oglądnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
oglądnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
oglądnąć: _: : perf: 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)}
ogniskować się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
ogniskować się: _: : imperf: subj{np(str)} + {xp(locat)}
ogniskować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ogniskować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
ogołacać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {refl}
ogołacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ogołocić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {refl}
ogołocić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ogorzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ograbiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ograbiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ograbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ograbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ograć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
ograć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
ograć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ograć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ograć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ogradzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
ogradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
ogradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
ogrodzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
ogrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ogrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
ogrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ogrodzić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
ogrywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
ogrywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ogrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
oheblować się: _: : perf: subj{np(str)} + {np(dat)}
oheblować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okadzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
okadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
okaleczać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
okaleczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okaleczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
okaleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
oklapnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
oklapnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
oklapnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
oklapnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
oklapnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
okopać się: _: : perf: subj{np(str)} + {np(inst)}
okopać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
okopać się: _: : perf: subj{np(str)} + {xp(locat)}
okopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
okopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okopcić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
okopcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okopcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
okopywać się: _: : imperf: subj{np(str)} + {np(inst)}
okopywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
okopywać się: _: : imperf: subj{np(str)} + {xp(locat)}
okopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
okopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
okopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
okorować: _: : 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)}
okrasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okraść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okraść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
okratować się: _: : perf: subj{np(str)}
okratować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okrawać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
okrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
okrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
okręcać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
okręcać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
okręcać się: _: : imperf: subj{np(str)} + {xp(adl)}
okręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
okręcić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
okręcić się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
okręcić: _: : perf: {np(str)}
okręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
okręcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
okroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okroić się: _: : perf: subj{np(str)} + {np(dat)}
okroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
okroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
okrwawić się: _: : perf: subj{np(str)}
okrwawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
okryć się: _: : perf: subj{np(str)} + {np(inst)}
okryć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {refl}
okryć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,acc)} + {refl}
okryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(od,gen)}
okryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,acc)}
okrywać się: _: : imperf: subj{np(str)} + {np(inst)}
okrywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {refl}
okrywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,acc)} + {refl}
okrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(od,gen)}
okrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,acc)}
okrzepnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
okrzyczeć: _: : perf: subj{np(str)} + controller{refl} + controllee{adjp(inst)}
okrzyczeć: _: : perf: subj{np(str)} + controller{refl} + controllee{np(inst)}
okrzyczeć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
okrzyczeć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
okrzyczeć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
okrzyczeć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
okrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
okrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
okrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
okrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
okrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
okrzykiwać: _: : imperf: subj{np(str)} + controller{refl} + controllee{adjp(inst)}
okrzykiwać: _: : imperf: subj{np(str)} + controller{refl} + controllee{np(inst)}
okrzykiwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
okrzykiwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
okrzykiwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
okrzykiwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
okrzyknąć: _: : perf: subj{np(str)} + controller{refl} + controllee{adjp(inst)}
okrzyknąć: _: : perf: subj{np(str)} + controller{refl} + controllee{np(inst)}
okrzyknąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
okrzyknąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
okrzyknąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
okrzyknąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
oksydować: _: : _: subj{np(str)} + obj{np(str)} + {advp(misc)}
oksydować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
okutać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
okutać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okutać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
okutać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
olbrzymieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
olbrzymieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
olbrzymieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
olbrzymieć: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
olbrzymieć: _: : imperf: subj{np(str)} + {xp(locat)}
olewać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
oliwić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oliwić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
olśnić: _: : perf: subj{cp(int); cp(że)} + {np(str)} + {cp(gdy); cp(kiedy)}
olśnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(gdy); cp(kiedy)}
olśnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
olśniewać: _: : imperf: subj{cp(int)} + {np(str)}
olśniewać: _: : imperf: subj{cp(że)} + {np(str)}
olśniewać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
olśniewać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
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)}
omotać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
omotać się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
omotać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
omotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
omotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
omotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
omotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
omotywać się: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(mod)}
omotywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
omotywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
omotywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
omotywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
omsknąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
omurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
omurować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
omyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
omyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
omyć: _: : perf: subj{np(str)} + {refl}
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)}
omywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
omywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
omywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
omywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
omywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
omywać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
opalizować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
opalizować: _: : imperf: subj{np(str)} + {advp(misc)}
opalizować: _: : imperf: subj{np(str)} + {np(inst)}
opalizować: _: : imperf: subj{np(str)} + obj{np(str)}
opalizować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
opalizować: _: : imperf: subj{np(str)} + {xp(locat)}
opamiętać się: _: : perf: subj{np(str)} + {cp(że)}
opamiętać się: _: : perf: subj{np(str)} + {or}
opamiętywać się: _: : imperf: subj{np(str)} + {cp(że)}
opamiętywać się: _: : imperf: subj{np(str)} + {or}
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}
opatulić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opatulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opatulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
opatulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opatulić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
opchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
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)}
opętać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
opiec się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc); prepnp(nad,inst); prepnp(przy,loc); prepnp(w,loc)} + {advp(misc)}
opiec się: _: : perf: subj{np(str)} + {np(gen)}
opiec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); prepnp(na,loc); prepnp(nad,inst); prepnp(przy,loc); prepnp(w,loc)} + {advp(misc)}
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)}
opiekać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepnp(nad,inst); prepnp(przy,loc); prepnp(w,loc)}
opiekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc); prepnp(nad,inst); prepnp(przy,loc); prepnp(w,loc)}
opiekować się: _: : imperf: subj{np(str)} + {np(inst)}
opieprzać się: _: : imperf: subj{np(str)}
opieprzać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
opieprzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
opieprzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
opieprzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
opieprzać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
opieprzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
opieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
opieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
opieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
opieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
opieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
opieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
opierdolić: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
opierdolić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
opierdolić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
opierdolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opierdolić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
opierdolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,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)}
oplątać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oplątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oplątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
oplątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
oplątać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
oplątać: _: : perf: subj{np(str)} + {prepnp(wokół,gen)} + {refl}
oplątywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
oplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
oplątywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
oplątywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
oplątywać: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)} + {refl}
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)}
oplombować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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łakać: _: : perf: subj{np(str)} + obj{np(str)}
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}
opłukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
opłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
opłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
opłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
opłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
opłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
opłukiwać: _: : imperf: subj{np(str)} + {prepnp(pod,inst)} + {refl}
opłukiwać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
opłukiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
opłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
opłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
opłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opłynąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
opływać: _: : imperf: subj{np(str)} + {np(inst)}
opływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
opływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
opływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opływać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
opływać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
opodatkować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opodatkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opodatkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opodatkować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
opodatkowywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
opodatkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opodatkowywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {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)}
oprać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
oprać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
oprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
oprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
oprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oprawny: : : : {prepnp(w,acc)}
oprocentować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
oprocentować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
oprotestować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
oprotestowywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
oprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
oprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
oprószyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
opryskać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
opryskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opryskiwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
opryskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
oprzytomnić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
oprzytomnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oprzytomnieć: _: : perf: subj{np(str)}
optować: _: : imperf: subj{np(str)} + {comprepnp(na rzecz)}
optować: _: : imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
optymalizować się: _: : imperf: subj{np(str)}
optymalizować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
opukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
opukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
opukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
opukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
opustoszeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
opuszczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
opuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
opuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
opuszczać: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
opuścić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
opuścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
opuścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
opuścić: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
opychać się: _: : imperf: subj{np(str)} + {np(inst)}
opychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
opychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opylać się: _: : imperf: controller{np(dat)} + controllee{infp(_)}
opylać się: _: : imperf: subj{np(str)} + {np(dat)}
opylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,acc)}
opylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
opylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
opylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
opylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opylić się: _: : perf: controller{np(dat)} + controllee{infp(_)}
opylić się: _: : perf: subj{np(str)} + {np(dat)}
opylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,acc)}
opylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
opylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
opylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
opylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
orbitować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(wokół,gen)}
orbitować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
orbitować: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)} + {xp(mod)} + {advp(misc)}
orbitować: _: : imperf: subj{np(str)} + {xp(adl)}
orbitować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
orzeźwiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
orzeźwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
orzeźwić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
orzeźwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
osaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
osaczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
osaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
osaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
osaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
osadzać się: _: : imperf: subj{np(str)} + {xp(locat)}
osadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
osadzić się: _: : perf: subj{np(str)} + {xp(locat)}
osadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
osadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
osamotnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
osamotnić: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
osączyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
osączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
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)}
oskalpować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
oskalpować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
oskalpować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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ładzać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
osładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
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łodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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łuchać się: _: : perf: subj{np(str)} + {np(dat)}
osłuchać się: _: : perf: subj{np(str)} + {np(gen)}
osłuchać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
osłuchać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
osłuchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osłuchiwać się: _: : imperf: subj{np(str)} + {np(dat)}
osłuchiwać się: _: : imperf: subj{np(str)} + {np(gen)}
osłuchiwać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
osłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
osłuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osłupieć: _: : perf: subj{np(str)} + {cp(że)}
osłupieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
osmagać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
osmagać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osmalać się: _: : imperf: subj{np(str)} + {np(inst)}
osmalać się: _: : imperf: subj{np(str)} + {xp(locat)}
osmalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osmalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
osmalić się: _: : perf: subj{np(str)}
osmalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osmolić się: _: : perf: subj{np(str)}
osmolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osnuć się: _: : perf: subj{np(str)} + {np(inst)}
osnuć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
osnuć się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
osnuć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
osnuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osnuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
osnuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
osnuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
osnuwać się: _: : imperf: subj{np(str)} + {np(inst)}
osnuwać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
osnuwać się: _: : imperf: subj{np(str)} + {prepnp(wokół,gen)}
osnuwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
osnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
osnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
osnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
osolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osowieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
osrać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
osrać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
osrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
ostrugać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
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)}
ostygnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ostygnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
ostygnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
ostygnąć: _: : perf: subj{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)}
oswobadzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oswobadzać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {refl}
oswobadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oswobadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
oswobadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oswobadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
oswobadzać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
oswobodzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oswobodzić: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {refl}
oswobodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oswobodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
oswobodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oswobodzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
oswobodzić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
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)}
osypać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
osypać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
osypać się: _: : perf: subj{np(str)} + {xp(adl)} + {advp(misc)}
osypać się: _: : perf: subj{np(str)} + {xp(locat)}
osypać się: _: : perf: subj{np(str)} + {xp(mod)}
osypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osypywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
osypywać się: _: : imperf: subj{np(str)} + {xp(locat)}
osypywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
osypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
oszalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oszałamiać się: _: : imperf: subj{np(str)} + {np(inst)}
oszałamiać: _: : imperf: subj{cp(int)} + obj{np(str)}
oszałamiać: _: : imperf: subj{cp(że)} + obj{np(str)}
oszałamiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
oszałamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
oszczenić się: _: : perf: subj{np(str)} + {np(dat)}
oszczenić się: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
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)}
oszołamiać się: _: : imperf: subj{np(str)} + {np(inst)}
oszołamiać: _: : imperf: subj{cp(int)} + obj{np(str)}
oszołamiać: _: : imperf: subj{cp(że)} + obj{np(str)}
oszołamiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
oszołamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
oszołomić się: _: : perf: subj{np(str)} + {np(inst)}
oszołomić: _: : perf: subj{cp(int)} + obj{np(str)}
oszołomić: _: : perf: subj{cp(że)} + obj{np(str)}
oszołomić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
oszołomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
oszronić się: _: : perf: subj{np(str)}
oszronić: _: : perf: subj{np(str)} + obj{np(str)}
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ślepnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
oślepnąć: _: : perf: subj{np(str)} + {prepnp(wskutek,gen)}
oślepnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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śmieszać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
ośmieszać się: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(wobec,gen)}
ośmieszać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
ośmieszać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
ośmieszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(przed,inst)}
ośmieszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(wobec,gen)}
ośmieszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
ośmieszać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(wobec,gen)}
ośmieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
ośmieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
ośmieszyć się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
ośmieszyć się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(wobec,gen)}
ośmieszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
ośmieszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
ośmieszyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(przed,inst)}
ośmieszyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(wobec,gen)}
ośmieszyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
ośmieszyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(wobec,gen)}
ośmieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
ośmieszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
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)}
otępiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
otępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otępieć: _: : perf: subj{np(str)}
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)}
otrzaskać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
otrzaskać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
otrzaskać się: _: : perf: subj{np(str)} + {xp(locat)}
otrzaskać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
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}
otumaniać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
otumaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
otumanić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
otumanić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
otwierać się: _: : imperf: subj{np(str)} + {np(dat)}
otwierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
otwierać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
otwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
otwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
otwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
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)}
otynkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
owdowieć: _: : perf: subj{np(str)}
owiać: _: : perf: {np(str)}
owiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owiązać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
owiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
owiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
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}
owionąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owładnąć: _: : perf: subj{np(str)} + {np(inst)}
owładnąć: _: : perf: subj{np(str)} + obj{np(str)}
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}
ozdrowieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
oziębiać się: _: : imperf: subj{E}
oziębiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(od,gen)}
oziębiać się: _: : imperf: {xp(dur)}
oziębiać się: _: : imperf: {xp(locat)}
oziębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
oziębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(od,gen)}
oziębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {xp(locat)}
oziębić się: _: : perf: {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
oziębić się: _: : perf: {prepnp(o,acc)} + {xp(locat)}
oziębić się: _: : perf: subj{E}
oziębić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(od,gen)}
oziębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
oziębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(od,gen)}
oziębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {xp(locat)}
oziębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
oziębnąć: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
ozłocić się: _: : perf: subj{np(str)} + {np(inst)}
ozłocić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
ozłocić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozłocić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
pacyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pacyfikować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'zarodek',natr)}
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)}
pajacować: _: : imperf: subj{np(str)}
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łać: _: : imperf: subj{np(str)} + {np(dat)}
pałać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pałać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
pałać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
pałać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pałaszować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
pałętać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
pałętać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
pałować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pałować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pałować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
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)}
panierować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
paplać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
paplać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
paplać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
paplać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
paplać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
paplać: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
paplać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
paplać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
paplać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
paplać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
paplać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
paplać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
paprać się: _: : imperf: subj{np(str)} + {np(dat)}
paprać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
paprać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
paprać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
paprać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
paprać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
paprać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
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)}
parafrazować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
parcelować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
parkować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
parkować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
parodiować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
parskać: _: : imperf: subj{np(str)} + {advp(misc)} + {or}
parskać: _: : imperf: subj{np(str)} + {cp(aż)}
parskać: _: : imperf: subj{np(str)} + {cp(że)}
parskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
parsknąć: _: : perf: subj{np(str)} + {np(inst)}
parsknąć: _: : perf: subj{np(str)} + {or}
partaczyć: _: : imperf: subj{np(str)} + obj{np(str)}
partaczyć: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
partnerować: _: : imperf: subj{np(str)} + {np(dat)}
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)}
paskudzić się: _: : imperf: subj{np(str)} + {np(dat)}
paskudzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
paskudzić: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
pasteryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {xp(dur)}
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)}
pauzować: _: : imperf: subj{np(str)}
pauzować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
pąsowieć: _: : imperf: subj{np(str)} + {np(inst)}
pąsowieć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
pąsowieć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
pąsowieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pąsowieć: _: : imperf: subj{np(str)} + {xp(locat)}
pąsowieć: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
pedałować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
pedałować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
pedałować: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)} + {xp(perl)}
peklować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
peklować się: _: : imperf: subj{np(str)} + {xp(locat)}
peklować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(locat)}
peklować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
peklować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(dur)} + {xp(locat)}
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)}
penalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
penetrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
percypować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
perfekcyjny: : : : {prepnp(w,loc); prepncp(w,loc,int)}
perforować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
perfumować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
perfumować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
perfumować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
perlić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
perlić się: _: : imperf: subj{np(str)} + {np(inst)}
perlić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
personifikować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
personifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
personifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
personifikować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
personifikować: _: : imperf: subj{np(str)} + {refl}
perswadować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
perswadować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
perswadować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
perswadować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
perswadować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
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ęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
pęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
pęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
pęcznieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pędzić: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
pędzić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pędzić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,loc)}
pędzić: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
pędzić: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
pędzić: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
pędzić: _: : imperf: subj{np(str)} + {xp(perl)}
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)}
piać: _: : imperf: subj{np(str)} + {cp(że)}
piać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
piać: _: : imperf: subj{np(str)} + {or}
piać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
piać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
piaskować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
pichcić się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
pichcić się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
pichcić się: _: : imperf: subj{np(str)} + {xp(locat)}
pichcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pichcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pichcić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pichcić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
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)}
pieklić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
pieklić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int); cp(że)}
pieklić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
pieklić się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pieklić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
pieklić się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,str,int)}
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)}
pieprznąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pieprznąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
pieprznąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
pieprznąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pieprznąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
pieprznąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
pieprznąć: _: : perf: subj{np(str)} + obj{np(str)}
pieprznąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
pieprznąć: _: : perf: subj{np(str)} + {prepnp(o,loc)}
pieprznąć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
pierniczyć się: _: : imperf: {np(dat)} + {cp(int)}
pierniczyć się: _: : imperf: {np(dat)} + {prepnp(w,loc)}
pierniczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pierniczyć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
pierniczyć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
pierniczyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pierniczyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
pierniczyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pierniczyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pierniczyć: _: : imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
pierniczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
pierniczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
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)}
piknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
piknąć: _: : perf: subj{np(str)} + {np(inst)}
piknąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
piknąć: _: : perf: subj{np(str)} + {xp(locat)}
pikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pikować: _: : imperf: subj{np(str)} + {xp(adl)}
pikować: _: : imperf: subj{np(str)} + {xp(locat)}
pilić: _: : imperf: {np(str)} + {xp(adl)}
pilić: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pilić: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
pilić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pilić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
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)}
pilotować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(mod)}
piłować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
piłować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
piłować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
piłować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
piorunować: _: : imperf: subj{np(str)} + {cp(że)}
piorunować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
piorunować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
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)}
pisywać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {or}
pisywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pisywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pisywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pisywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pisywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
pisywać: _: : 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)}
pisywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
pisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
pisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
pisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
pisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pisywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
pisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
pisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
pisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pisywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {cp(że)}
pisywać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {or}
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)}
plajtować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
plakatować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
plakatować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
plakatować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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}
plantować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
plenić się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
plenić się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'potęga',natr)}
plenić się: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
pleśnieć: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
pleśnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pleśnieć: _: : imperf: subj{np(str)} + {prepnp(wskutek,gen)}
pleśnieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pleśnieć: _: : imperf: subj{np(str)} + {xp(locat)}
plewić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
plisować się: _: : imperf: subj{np(str)}
plisować: _: : imperf: subj{np(str)} + obj{np(str)}
plombować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
plombować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
plonować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
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)}
plugawić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
plugawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
plugawić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {refl}
plunąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
plunąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
plunąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
plunąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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łaszczyć się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
płaszczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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łonić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
płonić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
płonić się: _: : imperf: subj{np(str)} + {xp(locat)}
płonić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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łowieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
płowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
płowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
płowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
płowieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
płożyć się: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
pobaraszkować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {xp(locat)}
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)}
pobeczeć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pobeczeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pobeczeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
pobeczeć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pobeczeć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pobeczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pobeczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pobeczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
pobeczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pobeczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pobeczeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pobeczeć: _: : perf: subj{np(str)} + {xp(dur)}
pobekiwać: _: : imperf: subj{np(str)} + {cp(że)}
pobekiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pobębnić: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
pobębnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pobębnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(do,gen,sg,'takt',ratr)}
pobębnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
pobębnić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
pobębnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
pobębnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pobębnić: _: : perf: subj{np(str)} + {prepnp(na,loc)}
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)}
pobiegać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
pobiegać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,acc)} + {xp(adl)}
pobiegać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pobiegać: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
pobiegać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pobiegać: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pobiegać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
pobiegać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(perl)}
pobiegać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pobiegać: _: : perf: subj{np(str)} + {xp(dur)}
pobiegać: _: : perf: subj{np(str)} + {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)}
pobijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pobijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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łyskiwać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
pobłyskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pobłyskiwać: _: : imperf: subj{np(str)} + {np(inst)}
pobłyskiwać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pobłyskiwać: _: : imperf: subj{np(str)} + {xp(abl)}
pobłyskiwać: _: : imperf: subj{np(str)} + {xp(locat)}
pobolewać: _: : imperf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
pobolewać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
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)}
pobratać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pobratać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
pobruździć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pobruździć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pobruździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pobruździć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pobruździć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
pobrykać: _: : perf: subj{np(str)} + {np(inst)}
pobrykać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pobrykać: _: : perf: subj{np(str)} + {xp(adl)}
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)}
pobuszować: _: : perf: subj{np(str)} + {prepnp(po,loc); xp(locat)}
pobyć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pobyć: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
pobyć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pobyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pobyć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
pochlapać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
pochlapać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pochlapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pochlapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pochlapać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pochlebiać: _: : imperf: subj{cp(że)} + {np(dat)}
pochlebiać: _: : imperf: subj{ncp(str,że)} + {np(dat)}
pochlebiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pochlebiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pochlebić: _: : perf: subj{cp(że)} + {np(dat)}
pochlebić: _: : perf: subj{ncp(str,że)} + {np(dat)}
pochlebić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pochlebić: _: : perf: subj{np(str)} + {np(dat)} + {or}
pochlipywać: _: : imperf: subj{np(str)} + {cp(int)}
pochlipywać: _: : imperf: subj{np(str)} + {cp(że)}
pochlipywać: _: : imperf: subj{np(str)} + {or}
pochlipywać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
pochlipywać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
pochlipywać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
pochlipywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
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)}
pochmurnieć: _: : _: subj{np(str)} + {np(dat)}
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)}
pochorować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pochorować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pochorować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pochorować: _: : perf: subj{np(str)} + {xp(dur)}
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)}
pochrząkiwać: _: : imperf: subj{np(str)} + {cp(żeby)}
pochrząkiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
pochrząkiwać: _: : imperf: subj{np(str)} + obj{np(str)}
pochrząkiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pochrząkiwać: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
pociec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
pociec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
pociec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
pociemnieć: _: : perf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(przed,inst,pl,'oko',natr)}
pociemnieć: _: : perf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
pociemnieć: _: : perf: {np(dat)} + {prepnp(z,gen)} + {preplexnp(przed,inst,pl,'oko',natr)}
pociemnieć: _: : perf: {np(dat)} + {prepnp(z,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
pociemnieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
pociemnieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pociemnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pociemnieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
pocierpieć: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
pocierpieć: _: : perf: subj{np(str)} + {np(str)}
pocierpieć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pocierpieć: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
pocierpieć: _: : perf: subj{np(str)} + {prepnp(za,acc)}
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)}
pociskać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(abl)} + {xp(adl)}
pociskać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
pociskać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pociskać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pociskać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
pociskać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
pociskać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
pociskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
pociskać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pociskać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
pociskać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
pocisnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pocisnąć się: _: : perf: subj{np(str)} + {xp(adl)}
pocisnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pocisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pocisnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pocisnąć: _: : perf: subj{np(str)} + {xp(adl)}
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)}
poczernieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
poczernieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poczernieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
poczernieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poczernieć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
poczernieć: _: : perf: subj{np(str)} + {prepnp(wskutek,gen)} + {xp(locat)}
poczernieć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
poczernieć: _: : perf: subj{np(str)} + {xp(locat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
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)}
poczłapać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
poczłapać: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
poczochrać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
poczochrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
poczochrać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poczochrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poczochrać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
poczochrać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
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)}
podążyć: _: : perf: subj{np(str)} + {np(inst)}
podążyć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podbarwić się: _: : perf: subj{np(str)} + {np(inst)} + {or}
podbarwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
podbarwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
podbarwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
podbarwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
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)}
podbierać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
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)}
podbudować się: _: : perf: subj{np(str)} + {cp(że)}
podbudować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
podbudować się: _: : perf: subj{np(str)} + {xp(mod)}
podbudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podbudowywać się: _: : imperf: subj{np(str)} + {cp(że)}
podbudowywać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
podbudowywać się: _: : imperf: subj{np(str)} + {xp(mod)}
podbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podbuntować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podbuntować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podbuntować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podbuntować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
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)}
podchować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
podciągać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
podciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podciągać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podciągać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
podciągać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
podciągać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
podciągać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
podciągać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
podciągać: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
podciągnąć się: _: : perf: subj{np(str)} + {np(dat)}
podciągnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
podciągnąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
podciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
podciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podciągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podciągnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
podciągnąć: _: : perf: subj{np(str)} + {prepnp(ku,dat)} + {refl}
podciągnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
podciągnąć: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
podciągnąć: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
podcieniować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podcierać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
podcierać: _: : imperf: 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)}
podczepić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
podczepić się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podczepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
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)}
podczytywać: _: : imperf: subj{np(str)} + {cp(int)}
podczytywać: _: : imperf: subj{np(str)} + {cp(że)}
podczytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
podczytywać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(int)}
podczytywać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
podczytywać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {or}
podczytywać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
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}
poddusić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
poddusić się: _: : perf: subj{np(str)} + {np(inst)}
poddusić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poddusić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
poddusić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poddusić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poddusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poddusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
poddusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poddusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
podebrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
podeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podeptać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
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)}
podeschnąć: _: : perf: subj{np(str)} + {np(dat)}
podesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
podesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podesłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
podesłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
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)}
podgrzać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
podgrzać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
podgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
podgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
podgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
podgrzewać się: _: : imperf: subj{np(str)} + {np(inst)}
podgrzewać się: _: : imperf: subj{np(str)} + {xp(locat)}
podgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
podjudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
podjudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
podjudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podjudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
podjudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
podjudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
podjudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podjudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
podkarmiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
podkarmiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podkarmić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
podkarmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podkasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podkasać: _: : perf: subj{np(str)} + {refl}
podkasywać się: _: : imperf: subj{np(str)} + {np(dat)}
podkasywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podkasywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podkleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podkleić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
podkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
podklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
podklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
podkopać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
podkopać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
podkopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podkopywać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
podkopywać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
podkopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podkpiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {cp(że)}
podkpiwać: _: : imperf: subj{np(str)} + {or}
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)}
podkształcić się: _: : perf: subj{np(str)} + {advp(misc)}
podkształcić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
podkształcić się: _: : perf: subj{np(str)} + {xp(locat)}
podkształcić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
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)}
podkupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podkupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podkurczać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podkurczać: _: : imperf: 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)}
podlatywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
podlatywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podlatywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podlecieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podleczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
podleczyć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen)}
podleczyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
podleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {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)}
podleźć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podliczać: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(w,loc,sg,'głowa',natr)}
podliczać: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(w,loc,sg,'pamięć',natr)}
podliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'głowa',natr)}
podliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'pamięć',natr)}
podliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
podliczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podliczyć: _: : perf: subj{np(str)} + {cp(int)}
podliczyć: _: : perf: subj{np(str)} + {cp(że)}
podliczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
podliczyć: _: : perf: subj{np(str)} + {or}
podlizać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
podlizywać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
podłamać się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
podłamać się: _: : perf: subj{np(str)} + {cp(int)}
podłamać się: _: : perf: subj{np(str)} + {cp(że)}
podłamać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podłamać: _: : perf: subj{cp(gdy)} + {np(str)}
podłamać: _: : perf: subj{cp(int)} + {np(str)}
podłamać: _: : perf: subj{cp(jak)} + {np(str)}
podłamać: _: : perf: subj{cp(jeśli)} + {np(str)}
podłamać: _: : perf: subj{cp(kiedy)} + {np(str)}
podłamać: _: : perf: subj{cp(że)} + {np(str)}
podłamać: _: : 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)}
podłamać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
podłapać: _: : perf: subj{np(str)} + {cp(int)}
podłapać: _: : perf: subj{np(str)} + {cp(że)}
podłapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podłazić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
podłazić: _: : imperf: subj{np(str)} + {cp(żeby)}
podłazić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podłazić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podłazić: _: : imperf: subj{np(str)} + {prepnp(do,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łubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podłubać: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
podłubać: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
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)}
podmakać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
podmakać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',atr)}
podmakać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
podmakać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
podmalować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
podmalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podmalowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podmalowywać: _: : imperf: subj{np(str)} + {refl}
podmarznąć: _: : perf: subj{np(str)}
podmawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
podmawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podmawiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
podmawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podmawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podmawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podmawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
podmawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podmiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podmieniać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
podmieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(na,acc)}
podmieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podmienić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
podmienić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(na,acc)}
podmienić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
podmoknąć: _: : perf: subj{np(str)}
podmówić się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
podmówić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podmówić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
podmówić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podmówić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podmówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podmówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
podmówić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podmuchać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podmuchać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
podmurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
podnająć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podnająć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podnająć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podnająć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podnająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podnająć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
podnajmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podnajmować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podnajmować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
podniecać się: _: : imperf: subj{np(str)} + {cp(int)}
podniecać się: _: : imperf: subj{np(str)} + {cp(że)}
podniecać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podniecać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
podniecać: _: : imperf: subj{cp(gdy)} + obj{np(str)} + {prepnp(do,gen)}
podniecać: _: : imperf: subj{cp(int)} + obj{np(str)} + {prepnp(do,gen)}
podniecać: _: : imperf: subj{cp(jak)} + obj{np(str)} + {prepnp(do,gen)}
podniecać: _: : imperf: subj{cp(jeśli)} + obj{np(str)} + {prepnp(do,gen)}
podniecać: _: : imperf: subj{cp(kiedy)} + obj{np(str)} + {prepnp(do,gen)}
podniecać: _: : imperf: subj{cp(że)} + obj{np(str)} + {prepnp(do,gen)}
podniecać: _: : 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)} + {prepnp(do,gen)}
podniecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podniecić się: _: : perf: subj{np(str)} + {cp(int)}
podniecić się: _: : perf: subj{np(str)} + {cp(że)}
podniecić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
podniecić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
podniecić: _: : perf: subj{cp(gdy)} + obj{np(str)} + {prepnp(do,gen)}
podniecić: _: : perf: subj{cp(int)} + obj{np(str)} + {prepnp(do,gen)}
podniecić: _: : perf: subj{cp(jak)} + obj{np(str)} + {prepnp(do,gen)}
podniecić: _: : perf: subj{cp(jeśli)} + obj{np(str)} + {prepnp(do,gen)}
podniecić: _: : perf: subj{cp(kiedy)} + obj{np(str)} + {prepnp(do,gen)}
podniecić: _: : perf: subj{cp(że)} + obj{np(str)} + {prepnp(do,gen)}
podniecić: _: : 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)} + {prepnp(do,gen)}
podniecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
podniszczyć się: _: : perf: subj{np(str)}
podnosić się: _: : imperf: subj{np(str)} + {or}
podnosić się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
podnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
podnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podnosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(locat)}
podnosić: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {or}
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)}
podobierać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
podobierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podobierać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
podobierać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
podobierać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
podobierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
podoczepiać się: _: : perf: subj{np(str)} + {np(gen)}
podoczepiać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
podoczepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podoczepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
podoczepiać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
podoczepiać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pododawać: _: : perf: subj{np(str)} + obj{np(gen)} + {xp(adl)}
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)}
podowcipkować: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
podowcipkować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
podowcipkować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)} + {lexnp(dat,_,'siebie',natr)}
podowcipkować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
podowcipkować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)} + {or}
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)}
podpełzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podpełzać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
podpełznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podpełznąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
podpiąć się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podpiąć się: _: : perf: subj{np(str)} + {xp(locat)}
podpiąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
podpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podpić: _: : perf: subj{np(str)} + {np(dat)}
podpić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)}
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)}
podpinać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podpinać się: _: : imperf: subj{np(str)} + {xp(locat)}
podpinać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
podpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
podpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
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)}
podpiwniczyć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
podprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
podprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
podprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podpuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
podpuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
podpuchnąć: _: : perf: subj{np(str)} + {xp(locat)}
podpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
podpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
podpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
podpuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
podpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
podpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
podpuścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podpytać się: _: : perf: subj{np(str)} + {np(gen)} + {cp(int)}
podpytać się: _: : perf: subj{np(str)} + {np(gen)} + {or}
podpytać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
podpytać: _: : perf: subj{np(str)} + obj{np(gen)} + {cp(int)}
podpytać: _: : perf: subj{np(str)} + obj{np(gen)} + {or}
podpytać: _: : perf: subj{np(str)} + obj{np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
podpytać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
podpytać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
podpytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
podpytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {cp(int)}
podpytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {or}
podpytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
podpytywać: _: : imperf: subj{np(str)} + obj{np(gen)} + {cp(int)}
podpytywać: _: : imperf: subj{np(str)} + obj{np(gen)} + {or}
podpytywać: _: : imperf: subj{np(str)} + obj{np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
podpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
podpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
podpytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
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)}
podrasować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
podrasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
podrasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
podrasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podrasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podrastać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
podrastać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podratować się: _: : perf: subj{np(str)} + {np(inst)}
podratować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
podratować: _: : perf: subj{np(str)} + {np(str)} + {advp(misc)}
podrażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podrażniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrażnić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
podrażnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podreperować się: _: : perf: subj{np(str)} + {advp(misc)}
podreperować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
podreperować się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
podreperować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
podroczyć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
podroczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
podroczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
podroczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
podroczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {or}
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)}
podruzgotać: _: : perf: subj{E} + obj{np(str)}
podruzgotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podruzgotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podrwiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
podrwiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
podrwiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
podrygiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
podrygiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(z,inst)}
podrygiwać: _: : imperf: subj{np(str)} + {prepnp(w,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)}
podrzemać: _: : perf: subj{np(str)} + {xp(locat)}
podrzemywać: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
podrzynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podsadzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)} + {refl}
podsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podsadzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)} + {refl}
podsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podsiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
podsiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
podsiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
podsiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podsiąkać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
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)}
podskubać: _: : perf: subj{np(str)} + obj{np(part)} + {xp(abl)}
podskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podskubać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
podskubać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
podskubać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
podskubać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podskubać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
podskubać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
podskubać: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
podskubać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
podskubywać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(abl)}
podskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
podskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
podskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
podskubywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podskubywać: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
podskubywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
podskubywać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
podskubywać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
podsmażać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
podsmażać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
podsmażać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
podsmażać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
podsmażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
podsmażać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podsmażyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
podsmażyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
podsmażyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
podsmażyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
podsmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
podsmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
podsuszać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
podsuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podsuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
podsuszać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
podsuszyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
podsuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podsuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
podsuszyć: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
podsychać: _: : imperf: subj{np(str)} + {np(dat)}
podsychać: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
podsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
podsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
podsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
podsyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
podsypać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
podsypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podsypywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
podsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
podszczypnąć: _: : perf: subj{np(str)} + obj{np(str)}
podszczypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podszczypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
podszczypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
podszczypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
podszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
podszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
podszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
podszepnąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
podszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
podszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
podszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
podszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
podszkolić się: _: : perf: subj{np(str)} + {cp(int)}
podszkolić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
podszkolić się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
podszkolić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
podszkolić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
podszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
podszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
podszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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ścielić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podścielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podścielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
podśmiewać się: _: : imperf: subj{np(str)} + {or}
podśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
podśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
podśpiewywać: _: : imperf: subj{np(str)} + {cp(że)}
podśpiewywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
podśpiewywać: _: : imperf: subj{np(str)} + {np(inst)} + {or}
podśpiewywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
podtuczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
podtuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podtuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
podtuczyć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
podtykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
poduczać 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)}
poduczać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
poduczać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
poduczać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
poduczać się: _: : imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
poduczać się: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
poduczać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
poduczać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
poduczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
poduczać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
poduczać: _: : 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)}
poduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
poduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
poduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
poduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poduczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poduczyć 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); prepnp(z,inst)}
poduczyć się: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
poduczyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
poduczyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
poduczyć się: _: : perf: subj{np(str)} + {np(gen)} + {xp(locat)}
poduczyć się: _: : perf: subj{np(str)} + {prepadjp(po,postp)}
poduczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poduczyć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
poduczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poduczyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poduczyć: _: : 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)}
poduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
poduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
poduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
poduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poduczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podumać: _: : perf: subj{np(str)} + {cp(int)}
podumać: _: : perf: subj{np(str)} + {cp(że)}
podumać: _: : perf: subj{np(str)} + {or}
podumać: _: : perf: 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)}
podupadać: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'rzecz',ratr)}
podupadać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
podupaść: _: : perf: subj{np(str)} + {prepnp(na,loc)}
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)}
podwędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podwiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podwiesić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {xp(locat)}
podwiesić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc)}
podwiesić się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
podwiesić się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
podwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)}
podwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
podwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
podwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(locat)}
podwieszać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
podwieszać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
podwieszać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
podwieszać się: _: : imperf: subj{np(str)} + {xp(locat)}
podwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
podwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
podwijać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podwijać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podwijać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podwinąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podwinąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podwinąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
podwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
podzelować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podzelować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
podziewać się: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
podżyrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podżyrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
poetyzować: _: : imperf: subj{np(str)} + {np(dat)}
poetyzować: _: : imperf: subj{np(str)} + obj{np(str)}
pofałdować się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
pofałdować się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',atr)}
pofałdować się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
pofałdować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pofałdować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
pofałdować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pofałdować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pofałdować: _: : perf: {np(dat)} + {np(str)}
pofałdować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pofałdować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pofałszować: _: : perf: subj{np(str)} + {cp(że)}
pofałszować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pofarbować się: _: : perf: subj{np(str)} + {advp(misc)}
pofarbować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pofarbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
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)}
poflirtować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pofolgować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pofolgować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pofrunąć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(nad,inst)}
pofrunąć: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pofrunąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pofrunąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
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)}
pogadywać: _: : imperf: subj{np(str)} + {cp(że)}
pogadywać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
pogalopować: _: : perf: subj{np(str)} + {np(inst)}
pogalopować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
pogapić się: _: : perf: subj{np(str)} + {cp(jak)}
pogapić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pogapić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
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)}
pogasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pogasić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pogasnąć: _: : perf: subj{np(str)} + {np(dat)}
pogasnąć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
poginąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
poginąć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poginąć: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
poginąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poginąć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
poginąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
pogmerać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
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)}
pognębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
pognębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pognębić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pognębić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
pognębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
pograć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
pograć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pograć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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)}
pogrubiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogrubić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogruchotać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pogruchotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogruchotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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)}
pogrymasić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pogrymasić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pogrymasić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
pogrywać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
pogrywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pogrywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pogrywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
pogrywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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}
pogrzać się: _: : perf: subj{np(str)} + {np(dat)}
pogrzać: _: : perf: {np(str)} + {prepnp(z,inst)}
pogrzać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pogrzać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
pogrzać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pogrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pogrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pogrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pogrzać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
pogrzać: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
pogrzać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
pogrzać: _: : perf: subj{np(str)} + {xp(dur)}
pogrzać: _: : perf: subj{np(str)} + {xp(locat)} + {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)}
pogwizdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
pogwizdywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
pogwizdywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
pogwizdywać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
pogwizdywać: _: : imperf: subj{np(str)} + {xp(locat)}
pogwizdywać: _: : imperf: subj{np(str)} + {xp(mod)}
pohałasować: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
pohałasować: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pohałasować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pohałasować: _: : perf: subj{np(str)} + {xp(locat)}
pohamować: _: : perf: subj{np(str)} + {cp(żeby)} + {refl}
pohamować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pohamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pohamować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pohamować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
pohańbić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
pohańbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pohańbić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
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)}
pohasać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pohasać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pohasać: _: : perf: subj{np(str)} + {xp(locat)}
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}
pohulać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {xp(locat)}
pohulać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pohulać: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {xp(locat)}
pohuśtać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pohuśtać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pohuśtać: _: : perf: subj{np(str)} + {np(inst)}
pohuśtać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pohuśtać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
poić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
poić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poić: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
poigrać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
poigrać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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)}
poinstruować się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
poinstruować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
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)}
pojadać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {lexnp(dat,_,'siebie',natr)}
pojadać: _: : imperf: subj{np(str)} + {np(inst)} + {lexnp(dat,_,'siebie',natr)}
pojadać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(inst)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
pojadać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {lexnp(dat,_,'siebie',natr)}
pojadać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
pojaśnieć: _: : perf: {np(dat)} + {xp(locat)}
pojaśnieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
pojaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pojaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'widok',atr)}
pojaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
pojaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pojaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
pojednać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(mod)}
pojednać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(mod)}
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)}
pojękiwać: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
pojękiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pojękiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pojękiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pojękiwać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
pojękiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pojękiwać: _: : imperf: subj{np(str)} + {np(str)}
pojękiwać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
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)}
pokajać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
pokajać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
pokajać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
pokajać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokalać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
pokalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
pokarać: _: : perf: {np(str)} + {cp(że)}
pokarać: _: : perf: {np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokarać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
pokarać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokarmić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
pokarmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
pokarmić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pokarmić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
pokasływać: _: : imperf: subj{np(str)}
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)}
pokaszliwać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pokaszliwać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
pokawałkować: _: : perf: {np(str)} + {prepnp(na,acc)}
pokawałkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,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ąpać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pokąpać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
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)}
pokibicować: _: : perf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
pokibicować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
pokibicować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pokiereszować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pokiereszować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
poklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
poklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poklasyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
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)}
poklękać: _: : 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łonić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pokłonić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(nad,inst)}
pokłonić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(przed,inst)}
pokłonić się: _: : perf: subj{np(str)} + {prepnp(ku,dat)}
pokłonić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(nad,inst)}
pokłonić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(przed,inst)}
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)}
pokłuć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {refl}
pokłuć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pokłuć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
pokłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pokłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pokłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pokłusować: _: : perf: subj{np(str)} + {xp(adl)}
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)}
pokolorować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
pokolorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pokołysać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pokołysać się: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
pokołysać: _: : perf: {np(inst)}
pokołysać: _: : perf: subj{np(str)} + obj{np(str)}
pokonać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokonywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokończyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
pokończyć się: _: : perf: subj{np(str)} + {xp(locat)}
pokończyć: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
pokończyć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
pokończyć: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
pokończyć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pokończyć: _: : perf: subj{np(str)} + {xp(locat)}
pokopać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pokopać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pokopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pokopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pokopać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pokornieć: _: : imperf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',natr)}
pokornieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
pokornieć: _: : imperf: subj{np(str)} + {prepnp(wobec,gen)}
pokornieć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pokornieć: _: : imperf: subj{np(str)} + {xp(mod)}
pokornieć: _: : imperf: subj{np(str)} + {xp(temp)}
pokosztować: _: : perf: subj{np(str)} + obj{np(part)}
pokpić: _: : perf: subj{np(str)} + {np(str)}
pokpić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
pokpić: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {lexnp(dat,_,'siebie',natr)} + {or}
pokpiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
pokpiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {lexnp(dat,_,'siebie',natr)} + {or}
pokrajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pokrajać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
pokraść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
pokreślić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
pokropić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pokropić: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
pokropić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pokropić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pokropić: _: : perf: subj{np(str)} + {xp(abl)}
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)}
pokrwawić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pokrwawić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pokrwawić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pokrwawić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pokrwawić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pokrwawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pokrwawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
pokrwawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
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)}
pokumać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pokumać: _: : perf: subj{np(str)} + {cp(int)}
pokumać: _: : perf: subj{np(str)} + {cp(że)}
pokumać: _: : perf: subj{np(str)} + {np(str)}
pokupować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pokupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pokupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
pokupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
pokupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
pokupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pokupować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
pokuśtykać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)} + {xp(perl)}
pokuśtykać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {xp(adl)} + {xp(perl)}
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)}
pokwapić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
pokwapić się: _: : perf: subj{np(str)} + {cp(żeby)}
pokwapić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pokwapić się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
pokwapić się: _: : perf: subj{np(str)} + {xp(adl)}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {or}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pokwękać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
pokwikiwać: _: : imperf: subj{np(str)} + {advp(misc)}
pokwikiwać: _: : imperf: subj{np(str)} + {cp(że)}
pokwikiwać: _: : imperf: subj{np(str)} + {cp(żeby)}
pokwikiwać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
pokwikiwać: _: : imperf: subj{np(str)} + {xp(abl)}
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)}
polaryzować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
polaryzować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
polaryzować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)}
polaryzować: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
polaryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc)}
polaryzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,loc)}
polatać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {lexnp(dat,_,'siebie',natr)}
polatać: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {lexnp(dat,_,'siebie',natr)}
polatać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
polatać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)} + {lexnp(dat,_,'siebie',natr)}
polatać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {lexnp(dat,_,'siebie',natr)}
polatać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)}
polatać: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(dat,_,'siebie',natr)}
polatać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
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)}
polegiwać: _: : imperf: subj{np(str)} + {xp(locat)}
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}
polepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
polepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
polepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
polepić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
polepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
polepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
polepić: _: : perf: subj{np(str)} + {prepnp(w,loc)}
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źć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
poleźć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)} + {xp(perl)}
poleżeć: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
policzkować się: _: : imperf: subj{np(str)} + {np(inst)}
policzkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
politurować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {advp(misc)}
politurować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
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)}
polonizować się: _: : imperf: subj{np(str)}
polonizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
polować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
polszczyć się: _: : imperf: subj{np(str)} + {advp(misc)}
polszczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
polśniewać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
polśniewać: _: : imperf: subj{np(str)} + {np(inst)}
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)}
polukrować: _: : perf: subj,controller{np(str)} + controllee{xp(locat)} + {refl}
polukrować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
polukrować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
polukrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polukrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
poluzować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poluzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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łakomić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
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łasić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
połasić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
połaskotać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
połaskotać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
połaskotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
połaskotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
połatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
poławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
połazić: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)} + {lexnp(dat,_,'siebie',natr)}
połazić: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
połazić: _: : perf: subj{cp(żeby)} + {prepnp(za,inst)}
połazić: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
połazić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
połazić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
połazić: _: : perf: subj{np(str)} + {prepnp(koło,gen)} + {lexnp(dat,_,'siebie',natr)}
połazić: _: : perf: subj{np(str)} + {prepnp(na,acc); xp(adl)} + {lexnp(dat,_,'siebie',natr)}
połazić: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)} + {lexnp(dat,_,'siebie',natr)}
połazić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(dat,_,'siebie',natr)}
połazić: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(dat,_,'siebie',natr)}
połazić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
połazić: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {lexnp(dat,_,'siebie',natr)}
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łupać: _: : perf: {np(str)} + {xp(locat)}
połupać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
połupać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
połupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
połupać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
połupać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
połupać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
połupać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
połykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
połyskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pomacać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pomacać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pomacać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pomacać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
pomacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pomacać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pomacać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pomacać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pomacać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pomacać: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pomacać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
pomalować: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
pomalować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
pomalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
pomalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pomarkotnieć: _: : perf: subj{np(str)}
pomarnować się: _: : perf: subj{np(str)}
pomarnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pomarnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,_,'siebie',natr)}
pomarszczyć się: _: : perf: subj{np(str)} + {np(dat)}
pomarszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomartwić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
pomartwić się: _: : perf: subj{np(str)} + {cp(int)}
pomartwić się: _: : perf: subj{np(str)} + {cp(że)}
pomartwić się: _: : perf: subj{np(str)} + {cp(żeby)}
pomartwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
pomartwić się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
pomartwić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
pomarznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pomarznąć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'kość',natr)}
pomarznąć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
pomącić się: _: : perf: subj{np(str)}
pomącić: _: : perf: subj{np(str)} + {advp(misc)}
pomącić: _: : perf: subj{np(str)} + {np(dat)}
pomącić: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pomdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pomdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pomedytować: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'temat',natr)}
pomedytować: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {xp(dur)}
pomedytować: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {xp(locat)}
pomęczyć się: _: : perf: subj{np(str)} + {np(inst)}
pomęczyć się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
pomęczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
pomęczyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
pomęczyć: _: : perf: subj{np(str)} + {np(str)} + {cp(żeby)}
pomiarkować się: _: : perf: subj{np(str)} + {cp(int)}
pomiarkować się: _: : perf: subj{np(str)} + {cp(że)}
pomiarkować się: _: : perf: subj{np(str)} + {or}
pomiarkować: _: : perf: subj{np(str)} + {cp(int)}
pomiarkować: _: : perf: subj{np(str)} + {cp(że)}
pomiarkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pomiarkować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
pomiatać: _: : imperf: subj{np(str)} + {np(inst)}
pomiaukiwać: _: : imperf: subj{np(str)}
pomiąć się: _: : perf: subj{np(str)} + {np(dat)}
pomiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pomiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pomierzyć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
pomierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pomierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pomierzyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
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)}
pomieszkać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(dur)}
pomieszkać: _: : perf: subj{np(str)} + {prepnp(u,gen); xp(locat)} + {xp(dur)}
pomieszkać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)}
pomieszkiwać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
pomieszkiwać: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
pomilczeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)} + {prepnp(z,inst)}
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)}
pomlaskać: _: : perf: subj{np(str)} + {np(inst)}
pomlaskiwać: _: : imperf: subj{np(str)} + {np(inst)}
pomlaskiwać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
pomocować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pomocować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pomoczyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pomoczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pomoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pomoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
pomordować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pomordować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
pompować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
pompować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
pompować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pompować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pompować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pompować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pompować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
pomruczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
pomruczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pomruczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pomruczeć: _: : perf: subj{np(str)} + {np(dat)} + {or}
pomruczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
pomruczeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomruczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pomruczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(za,inst)} + {nonch}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(int)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
pomruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
pomrukiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
pomrukiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch} + {xp(adl)}
pomrukiwać: _: : imperf: subj{np(str)} + {or}
pomrukiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pomrukiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
pomrzeć: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
pomrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pomrzeć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
pomrzeć: _: : perf: subj{np(str)} + {prepnp(wskutek,gen)}
pomrzeć: _: : perf: subj{np(str)} + {prepnp(za,acc)}
pomrzeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
pomyszkować: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pomyszkować: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(locat)}
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}
ponabijać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ponabijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ponabijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ponaciągać się: _: : perf: subj{np(str)} + {advp(misc)}
ponaciągać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
ponaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ponaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ponaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
ponacinać się: _: : perf: subj{np(str)} + {np(inst)}
ponacinać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
ponacinać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
ponacinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ponacinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
ponaklejać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ponakładać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ponakładać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
ponakładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ponakładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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)}
ponalepiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ponalepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ponalepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
ponapełniać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
ponapełniać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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}
ponarzekać: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'sobie',natr)}
ponarzekać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'sobie',natr)}
ponarzekać: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(dat,_,'sobie',natr)} + {or}
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)}
ponaszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ponaszywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
ponawlekać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
poniszczyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
poniszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
poobcinać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
poobcinać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poobcinać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poobcinać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
poobcinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
poobcinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poobcinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
poobdzierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poobdzierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
poobdzierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poobdzierać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poobdzierać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
poobdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poobdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
poobdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poobdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
poobgryzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobgryzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
poobliczać: _: : perf: subj{np(str)} + {np(inst)} + {cp(int)}
poobliczać: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
poobliczać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
poobliczać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,loc)}
poobliczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poobliczać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
poobliczać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
poobłamywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
poobrywać się: _: : perf: subj{np(str)}
poobrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poobrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poobrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
poobsadzać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poobsadzać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
poobsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
poobsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poobsadzać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
poobsadzać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
poobserwować: _: : perf: subj{np(str)} + {cp(int)}
poobserwować: _: : perf: subj{np(str)} + {cp(jak)}
poobserwować: _: : perf: subj{np(str)} + {cp(że)}
poobserwować: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
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)}
poobtłukiwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poobtłukiwać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poobtłukiwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
poobtłukiwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poobtłukiwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobtłukiwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poobtłukiwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
poobtłukiwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
poobtykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobtykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
poobwiązywać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poobwiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobwiązywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poobwieszać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poobwieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poobwieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poobwieszać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
poobwijać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
poobwijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poobwijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poobwijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
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)}
poodbijać się: _: : perf: {np(dat)} + {np(inst)}
poodbijać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poodbijać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poodbijać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
poodbijać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
poodbijać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
poodbijać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poodbijać się: _: : perf: subj{np(str)} + {xp(locat)}
poodbijać: _: : perf: {np(dat)} + {prepnp(z,inst)}
poodbijać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
poodbijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poodbijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
poodbijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
poodbijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poodbijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
poodcinać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
poodcinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poodcinać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pooddawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pooddawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pooddawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pooddawać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pooddzielać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {refl}
pooddzielać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
pooddzielać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
pooddzielać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
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)}
poodklejać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poodklejać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poodklejać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poodklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poodklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poodklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
poodkręcać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
poodkręcać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
poodmrażać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
poodpadać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {xp(abl)}
poodpadać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {xp(locat)}
poodpadać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poodpruwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
poodpruwać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poodpruwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
poodpruwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poodrąbywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
poodrąbywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poodrąbywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poodrywać się: _: : perf: subj{np(str)} + {xp(abl)}
poodrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
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)}
poodwracać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
poodwracać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
poodwracać: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'kot',natr)} + {lexnp(inst,sg,'ogon',natr)}
poodwracać: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('do góry nogami')}
poodwracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poodwracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poodwracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
poodwracać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
poodwracać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
pookręcać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pookręcać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
pookręcać się: _: : perf: subj{np(str)} + {xp(adl)}
pookręcać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pookręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pookręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pookręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pookręcać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pookrywać się: _: : perf: subj{np(str)} + {np(inst)}
pookrywać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {refl}
pookrywać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,acc)} + {refl}
pookrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pookrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pookrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(od,gen)}
pookrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(po,acc)}
pookrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {prepnp(w,acc)}
pookrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(po,acc)} + {prepnp(w,acc)}
pookrywać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {prepnp(w,acc)} + {refl}
pookrywać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(po,acc)} + {prepnp(w,acc)} + {refl}
poopalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poopalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poopalać: _: : perf: subj{np(str)} + {xp(dur)}
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)}
pooprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pooprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poopuszczać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poopuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poopuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poopuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
poopuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poopuszczać: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
poorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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}
pootwierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pootwierać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
pootwierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pootwierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
poowijać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poowijać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poowijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poowijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
poowijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
poowijać: _: : 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)}
popalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popalić się: _: : perf: subj{np(str)} + {np(inst)}
popalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
popalić się: _: : perf: subj{np(str)} + {xp(locat)}
popalić: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'most',atr)} + {preplexnp(za,inst,sg,'siebie',natr)}
popalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
popalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
popalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
popalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
poparzyć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
poparzyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poparzyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
poparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popasać: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
popatrywać: _: : imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
popatrywać: _: : imperf: subj{np(str)} + {cp(jak)}
popatrywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
popatrywać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
popatrywać: _: : imperf: subj{np(str)} + {prepnp(przez,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)}
popieścić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
popieścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
popijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popijać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
popilnować: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {cp(żeby)}
popilnować: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(przed,inst)}
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)}
popiskiwać: _: : imperf: subj{np(str)} + {cp(że)}
popiskiwać: _: : imperf: subj{np(str)} + {or}
popiskiwać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
popiskiwać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
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)}
popleść się: _: : perf: subj{np(str)}
popleść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
popleść: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
popleść: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
popleść: _: : perf: subj{np(str)} + {np(dat)} + {or}
popleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
popleść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
popleść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
poplotkować: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
poplotkować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
poplotkować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
poplotkować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
popluć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
popluć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
popluć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
popluć: _: : perf: subj{np(str)} + obj{np(str)}
popluskać się: _: : perf: subj{np(str)} + {np(inst)}
popluskać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
popluskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(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łakiwać: _: : imperf: subj{np(str)} + {cp(że)}
popłakiwać: _: : imperf: subj{np(str)} + {or}
popłakiwać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
popłakiwać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
popłakiwać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
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)}
poprać się: _: : perf: subj{np(str)} + {xp(locat)}
poprać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
poprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
poprać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
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óbować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
popróbować: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
popróbować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'siła',batr)}
popróbować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'szczęście',atr)}
popróbować: _: : perf: subj{np(str)} + {cp(int)}
popróbować: _: : perf: subj{np(str)} + {np(gen)}
popróbować: _: : perf: subj{np(str)} + {np(str)}
popróbować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,pl,'siła',batr)}
popróbować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,sg,'szczęście',atr)}
popróbować: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(gen,pl,'siła',batr)}
popróbować: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(gen,sg,'szczęście',atr)}
popróchnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popróchnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
popruć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
popruć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
popruć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
popruć: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
popruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popruć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
popruć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
popruć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
popruć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
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}
poprzebijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
poprzecierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poprzecierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poprzecierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poprzecierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzecierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poprzecierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
poprzedzielać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzedzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poprzeglądać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poprzeglądać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poprzegradzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzekładać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
poprzekręcać się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
poprzekręcać się: _: : perf: subj{np(str)}
poprzekręcać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
poprzekręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
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)}
poprzemieniać się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
poprzemieniać się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
poprzemieniać się: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
poprzemieniać się: _: : perf: subj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)}
poprzemieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(inst)}
poprzemieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(inst)}
poprzemieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {np(inst)}
poprzemieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)} + {np(inst)}
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)}
poprzerywać się: _: : perf: subj{np(str)}
poprzerywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzerywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
poprzerzynać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
poprzesuwać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
poprzesuwać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
poprzesuwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
poprzesuwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
poprzewracać się: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
poprzewracać się: _: : perf: {np(dat)} + {xp(locat)}
poprzewracać się: _: : perf: subj{np(str)} + {np(dat)}
poprzewracać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poprzewracać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poprzewracać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
poprzewracać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
poprzewracać: _: : perf: subj{np(str)} + {np(inst)}
poprzewracać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzewracać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poprzewracać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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}
poprzybijać: _: : perf: subj{np(str)} + obj{lexnp(str,_,'piątka',natr)} + {prepnp(z,inst)}
poprzybijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
poprzybijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
poprzycinać: _: : perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,sg,'drzemka',atr)}
poprzycinać: _: : perf: subj{np(str)} + {lexnp(str,sg,'komar',natr)}
poprzycinać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poprzycinać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poprzyczepiać się: _: : perf: subj{np(str)} + {cp(int)}
poprzyczepiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
poprzyczepiać się: _: : perf: subj{np(str)} + {xp(locat)}
poprzyczepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
poprzyczepiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poprzyjeżdżać: _: : perf: subj{np(str)} + {np(inst)}
poprzyjeżdżać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poprzyjeżdżać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poprzyjeżdżać: _: : perf: subj{np(str)} + {prepnp(po,acc)}
poprzyjeżdżać: _: : perf: subj{np(str)} + {prepnp(za,inst)}
poprzyjeżdżać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
poprzyklejać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
poprzyklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poprzyklejać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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)}
poprzylepiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
poprzylepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
poprzylepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
poprzylepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poprzylepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(na,acc)}
poprzylepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(adl)}
poprzylepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
poprzynosić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
poprzypinać się: _: : perf: subj{np(str)}
poprzypinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
poprzypinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
poprzysiąc: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
poprzysiąc: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
poprzysiąc: _: : perf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,że)}
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}
poprzysuwać się: _: : perf: subj{np(str)} + {xp(adl)}
poprzysuwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
poprzyszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
poprzytulać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
poprzytulać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poprzytulać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
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)}
popuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
popuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',atr)}
popuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
popuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
popuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
popuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
popuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
popularyzować się: _: : imperf: subj{np(str)} + {xp(locat)}
popularyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
popuszczać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(o,acc)} + {xp(abl)}
popuszczać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(o,acc)} + {xp(locat)}
popuszczać: _: : imperf: subj{np(str)} + obj{np(part)} + {xp(adl)}
popuścić: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(o,acc)} + {xp(abl)}
popuścić: _: : perf: subj{np(str)} + obj{np(str)}
popuścić: _: : perf: subj{np(str)} + {prepnp(w,loc)}
popuścić: neg: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
popuścić: neg: : perf: subj{np(str)} + obj{np(str)} + {lexnp(inst,sg,'płaz',natr)}
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)}
popytać się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(na temat)}
popytać się: _: : perf: subj{np(str)} + {np(gen)} + {cp(int)}
popytać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
popytać: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(na temat)}
popytać: _: : perf: subj{np(str)} + {np(gen)} + {cp(int)}
popytać: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
popytać: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(na temat)}
popytać: _: : perf: subj{np(str)} + {np(str)} + {cp(int)}
popytać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
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)}
porachować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
porachować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,loc)}
porachować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
porachować: _: : perf: subj{np(str)} + {prepnp(do,gen)}
porachować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
porachować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
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)}
poranić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poranić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poranić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poranić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
poranić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
poranić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poranić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
poranić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poranić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poranić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
poranić: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
poranić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
poranić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
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)}
poratować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
poratować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
porąbać: _: : perf: {np(str)}
porąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
porąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
porcjować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pordzewieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
pordzewieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
pordzewieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
pordzewieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
porozbierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
porozbierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
porozbierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
porozbierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
porozbierać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
porozbierać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
porozchodzić się: _: : perf: subj{np(str)} + {xp(adl)}
porozchodzić się: _: : perf: subj{np(str)} + {xp(locat)}
porozciągać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
porozciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
porozdawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
porozdawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
porozdawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
porozdzielać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
porozdzielać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
porozdzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
porozdzielać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
porozdzierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
porozdzierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porozdzierać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
porozdzierać się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(locat)}
porozdzierać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
porozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
porozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
porozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
porozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {xp(locat)}
porozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
porozklejać się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
porozklejać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',natr)}
porozklejać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
porozklejać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
porozklejać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porozklejać się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'myśl',natr)}
porozklejać się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'widok',natr)}
porozklejać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
porozklejać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
porozklejać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
porozklejać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
porozklejać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porozkładać się: _: : perf: subj{np(str)} + {prepnp(między,acc)}
porozkładać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
porozkładać się: _: : perf: subj{np(str)} + {xp(locat)}
porozkładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
porozkładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
porozkładać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porozkradać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
porozkręcać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
porozkręcać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
porozlepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
porozlewać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {xp(adl); xp(locat)}
porozlewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl); xp(locat)}
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)}
porozmieszczać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
porozmieszczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porozmyślać się: _: : perf: subj{np(str)}
porozmyślać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
porozmyślać: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
porozmyślać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
porozmyślać: _: : perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
porozmyślać: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {lexnp(dat,_,'siebie',natr)}
porozmyślać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {lexnp(dat,_,'siebie',natr)}
poroznosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poroznosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {cp(żeby)}
poroznosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',ratr)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
porozpadać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porozpinać się: _: : perf: subj{np(str)} + {np(dat)}
porozpinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porozpinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
porozpinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
porozpinać: _: : perf: subj{np(str)} + {refl}
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)}
porozrzucać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
porozrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
porozrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
porozrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
porozsadzać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
porozsadzać się: _: : perf: subj{np(str)} + {xp(adl)}
porozsadzać się: _: : perf: subj{np(str)} + {xp(locat)}
porozsadzać się: _: : perf: subj{np(str)} + {xp(perl)}
porozsadzać: _: : perf: {np(dat)} + {np(str)} + {prepnp(od,gen)}
porozsadzać: _: : perf: {np(dat)} + {np(str)} + {prepnp(z,gen)}
porozsadzać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
porozsadzać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
porozsadzać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
porozsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
porozsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
porozsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
porozsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porozsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
porozsiadać się: _: : perf: subj{np(str)} + {xp(locat)}
porozstawiać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porozstawiać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
porozstawiać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
porozstawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
porozstawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
porozsychać się: _: : perf: subj{np(str)}
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)}
porozwalać się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
porozwalać się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
porozwalać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
porozwalać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
porozwalać się: _: : perf: subj{np(str)} + {xp(locat)}
porozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
porozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
porozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
porozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
porozwalać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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}
poróżnić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
poróżnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(z,inst)}
poróżowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poróżowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
poróżowieć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
poróżowieć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
portretować się: _: : imperf: subj{np(str)}
portretować: _: : imperf: subj{np(str)} + obj{np(str)}
portretować: _: : imperf: subj{np(str)} + {refl}
poruczyć: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
poruczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
poruczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
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)}
porysować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
porysować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
porysować się: _: : perf: subj{np(str)} + {xp(locat)}
porysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
porysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
porysować: _: : perf: subj{np(str)} + {refl}
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)}
porznąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
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)}
porzygać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
porzygać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
porzygać się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
porzygać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
porzygać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
porżnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
porżnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
porżnąć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
porżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
porżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
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)}
poschodzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
poschodzić: _: : perf: subj{np(str)} + {np(dat)}
poschodzić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(z,gen)}
poschodzić: _: : perf: subj{np(str)} + {xp(locat)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(inst,sg,'wzgląd',ratr)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',ratr)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'wzgląd',ratr)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
posegregować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
posiekać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
posiekać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posiekać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
posiekać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
posikać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
posikać się: _: : perf: subj{np(str)} + {np(inst)}
posikać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
posikać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
posikać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
posikać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
posikać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
posikać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(temp)}
posikać: _: : perf: subj{np(str)} + obj{np(str)}
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)}
posiniaczyć się: _: : perf: subj{np(str)}
posiniaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posinieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
posinieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
posinieć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
posinieć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
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)}
poskakać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
poskakać: _: : perf: subj{np(str)} + {prepnp(koło,gen)}
poskakać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poskakać: _: : perf: subj{np(str)} + {prepnp(po,loc)}
poskakać: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
poskakać: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
poskakać: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poskakać: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
poskakać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
posklejać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
posklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
posklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
posklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
poskładać się: _: : perf: {np(dat)} + {cp(że)} + {advp(misc)}
poskładać się: _: : perf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
poskładać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
poskładać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
poskładać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(po,acc)}
poskładać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
poskładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poskładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poskładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
poskładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poskładać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
poskładać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poskładać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
poskoczyć: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
poskoczyć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
poskracać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
poskracać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
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)}
poskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
poskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
poskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
poskrobać: _: : perf: subj{np(str)} + {np(dat)} + {or}
poskrobać: _: : 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)}
poskrobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poskrobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poskrobać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
poskrobać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
poskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
poskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
poskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
poskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
poskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
poskrobać: _: : 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)}
poskromić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poskrzypywać: _: : imperf: {np(dat)} + {xp(locat)}
poskrzypywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
poskubać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poskubać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poskubać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
poskubać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poskubać: _: : perf: subj{np(str)} + obj{np(part)} + {np(inst)} + {xp(abl)}
poskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
poskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
poskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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łodzić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
posłodzić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
posłodzić: _: : perf: subj{np(str)} + {np(dat)} + {or}
posłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
posmarować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
posmarować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
posmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
posmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
posmarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
posmutnieć: _: : perf: subj{np(str)} + {cp(że)}
posmutnieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
posmutnieć: _: : perf: subj{np(str)} + {or}
posnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
posnąć: _: : perf: subj{np(str)} + {xp(locat)}
posolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posolić: _: : perf: subj{np(str)} + {refl}
posortować się: _: : perf: subj{np(str)} + {advp(misc)}
posortować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
posortować się: _: : perf: subj{np(str)} + {prepnp(według,gen)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(według,gen)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',atr)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'wzgląd',atr)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
posortować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pospacerować: _: : perf: subj{np(str)} + {xp(perl)}
pospać: _: : perf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
pospać: _: : perf: subj{np(str)} + {np(dat)} + {prepadjp(na,loc)}
pospać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
pospać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(u,gen)}
pospać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {advp(misc)}
pospać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pospać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
pospać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pospadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pospadać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pospadać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
pospadać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
pospadać: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
pospadać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
pospawać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pospawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pospawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
pospieszać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)}
pospieszać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
pospieszać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
pospieszać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pospieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pospieszać: _: : imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(perl)}
pospieszać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
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)}
pospinać się: _: : perf: subj{np(str)} + {cp(żeby)}
pospinać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
pospinać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pospinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
pospinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pospinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pospinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,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)}
posplatać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
posplatać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
posplatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
posplatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pospłacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
posprzeczać się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
posprzedawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,acc)}
posprzedawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
posprzedawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
posprzedawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
pospuszczać się: _: : perf: subj{np(str)} + {xp(adl)}
pospuszczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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(_)}
postarzać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
postarzać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
postarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
postarzać: _: : imperf: subj{np(str)} + {refl}
postarzeć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
postarzeć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
postarzeć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
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ąpić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {comprepnp(w kwestii)}
postąpić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {comprepnp(w sprawie)}
postąpić: _: : perf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
postąpić: _: : perf: subj{np(str)} + {np(str)} + {xp(adl)}
postąpić: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(adl)}
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)}
postradać: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'zmysł',natr)}
postradać: _: : perf: subj{np(str)} + obj{lexnp(str,sg,'rozum',natr)}
postradać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
postradać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
postraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
postraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); cp(że); ncp(inst,że)}
postraszyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
postrącać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
postrącać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
postroić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
postroić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
postroić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
postroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
postroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
postroić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
postrzec się: _: : perf: subj{np(str)} + {cp(gdy)}
postrzec się: _: : perf: subj{np(str)} + {cp(int)}
postrzec się: _: : perf: subj{np(str)} + {cp(jak)}
postrzec się: _: : perf: subj{np(str)} + {cp(kiedy)}
postrzec się: _: : perf: subj{np(str)} + {cp(że)}
postrzec: _: : perf: subj{np(str)} + {cp(gdy)}
postrzec: _: : perf: subj{np(str)} + {cp(int)}
postrzec: _: : perf: subj{np(str)} + {cp(jak)}
postrzec: _: : perf: subj{np(str)} + {cp(kiedy)}
postrzec: _: : perf: subj{np(str)} + {cp(że)}
postrzec: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
postrzec: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
postrzec: _: : perf: subj{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
postrzegać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
postrzegać: _: : imperf: subj{np(str)} + {cp(int)}
postrzegać: _: : imperf: subj{np(str)} + {cp(że)}
postrzegać: _: : imperf: subj{np(str)} + {ncp(str,int)}
postrzegać: _: : imperf: subj{np(str)} + {ncp(str,że)}
postrzegać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
postrzegać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
postrzegać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
postrzelać się: _: : perf: subj{np(str)} + {np(inst)}
postrzelać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
postrzelać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
postrzelać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
postrzelać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
postrzelać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
postrzelać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
postrzelać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
postrzelać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
postrzelać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
postrzelić: _: : perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
postrzelić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
postrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
postrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
postrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
postrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {advp(misc)}
postrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
postrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {advp(misc)}
postrzelić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {advp(misc)} + {refl}
postrzelić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)} + {refl}
postrzelić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {advp(misc)} + {refl}
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)}
postukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
postukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
postukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
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)}
posyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
posyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
posyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
posyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
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)}
poszaleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
poszaleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
poszaleć: _: : perf: subj{np(str)} + {np(inst)}
poszaleć: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
poszaleć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poszaleć: _: : perf: subj{np(str)} + {prepnp(za,gen)}
poszaleć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poszaleć: _: : perf: subj{np(str)} + {xp(locat)}
poszarpać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poszarpać się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
poszarpać się: _: : perf: subj{np(str)} + {xp(locat)}
poszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
poszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
poszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
poszarzeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poszarzeć: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
poszarzeć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
poszarzeć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
poszatkować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poszatkować się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
poszatkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
poszatkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
poszatkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
poszczekać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
poszczekiwać: _: : imperf: subj{np(str)} + {or}
poszczekiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
poszczekiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
poszczekiwać: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
poszczekiwać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
poszczerbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
poszczerbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poszczęścić się: _: : perf: {np(dat)} + {prepnp(z,inst)}
poszczęścić się: _: : perf: {np(dat)} + {xp(locat)}
poszczęścić: _: : perf: subj{np(str)} + {np(dat)}
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)}
poszeptać: _: : perf: subj{np(str)} + {cp(int)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptać: _: : perf: subj{np(str)} + {cp(żeby)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptać: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
poszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptać: _: : perf: 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)}
poszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poszeptać: _: : perf: subj{np(str)} + {prepadjp(po,postp)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptać: _: : perf: subj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)} + {or}
poszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
poszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
poszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
poszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
poszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
poszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
poszeptać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
poszeptać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
poszeptywać: _: : imperf: subj{np(str)} + {cp(int)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptywać: _: : imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptywać: _: : imperf: subj{np(str)} + {cp(że)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
poszeptywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptywać: _: : 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)}
poszeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
poszeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
poszeptywać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptywać: _: : imperf: subj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)} + {or}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {preplexnp(między,inst,sg,'siebie',natr)}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
poszeptywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
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)}
poszkodować: _: : perf: subj{E} + obj{np(str)} + {prepnp(od,gen)} + {advp(misc)}
poszkodować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
poszperać: _: : perf: subj{np(str)} + {xp(locat)}
posztukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poszturchać się: _: : perf: subj{np(str)} + {np(inst)}
poszturchać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poszturchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poszturchać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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ściągać się: _: : perf: subj{np(str)} + {np(dat)}
pościągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
pościągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pościągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pościągać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
pościć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
pościelić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pościelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pościerać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pościerać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pościerać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pościerać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pościerać się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
pościerać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pościerać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pościerać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
pościnać: _: : 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ślizgać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poślizgać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poślizgać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
poślizgać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
poślizgać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
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śpieszać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)}
pośpieszać się: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
pośpieszać: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
pośpieszać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pośpieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pośpieszać: _: : imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(perl)}
pośpieszać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
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śpiewywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
pośpiewywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pośpiewywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
poświstywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
poświstywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
poświstywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
potakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
potakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
potakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
potakiwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
potanieć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
potańczyć: _: : perf: subj{np(str)} + obj{np(str)}
potańczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
potańczyć: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
potańczyć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
potargać się: _: : perf: subj{np(str)} + {np(dat)}
potargać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
potargać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
potargać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
potargać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
potargać: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
potargować się: _: : perf: subj{np(str)} + {comprepnp(co do)}
potargować się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
potargować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
potarmosić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
potarmosić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
potarmosić: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
potarmosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
potarmosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
potarmosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
potarmosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
potarmosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
potasować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
potasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,inst)}
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)}
potężnieć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
potężnieć: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
potężnieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
potężnieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
potężnieć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
potężnieć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
potężnieć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
potoczyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
potoczyć się: _: : perf: subj{np(str)} + {xp(mod)}
potoczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
potoczyć: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
potoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
potracić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
potracić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
potracić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
potracić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(podczas,gen)}
potracić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
potracić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
potracić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {nonch}
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)}
potrenować: _: : perf: subj{np(str)} + {np(inst)}
potrenować: _: : perf: subj{np(str)} + {np(str)}
potrenować: _: : perf: subj{np(str)} + {prepnp(do,gen)}
potrenować: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
potrenować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
potrenować: _: : perf: subj{np(str)} + {xp(locat)}
potroić się: _: : perf: subj{np(str)}
potroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
potruć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
potruć się: _: : perf: subj{np(str)} + {xp(locat)}
potruć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {xp(dur)}
potruć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(dur)}
potruć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(dur)}
potruć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(dur)}
potruć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
potruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
potrzymać się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
potrzymać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
potrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
potrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
potrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
potrzymać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
potrzymać: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
potrzymać: _: : perf: subj{np(str)} + {xp(temp)}
poturbować się: _: : perf: subj{np(str)} + {advp(pron)}
poturbować się: _: : perf: subj{np(str)} + {xp(locat)}
poturbować się: _: : perf: subj{np(str)} + {xp(temp)}
poturbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poturbować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poturbować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
poubierać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
poubierać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
poubierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poubierać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
pouciekać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
pouciekać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pouciekać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
pouciekać: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)}
pouciekać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
poucinać: _: : 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)}
poumierać: _: : perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
poumierać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
poumierać: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
poumierać: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
poumieszczać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poumieszczać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
poupadać: _: : perf: {prepnp(na,acc)} + {xp(locat)}
poupadać: _: : perf: subj{np(str)} + {advp(misc)}
poupadać: _: : perf: subj{np(str)} + {np(inst)}
poupadać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poupadać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
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)}
pourywać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pourywać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pourywać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pourywać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
pourywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pourywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pourywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
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)}
poustawiać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
poustawiać się: _: : perf: subj{np(str)} + {xp(locat)}
poustawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
poustawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
poustawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poustawiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poustawiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
poutykać: _: : perf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {xp(adl)}
poutykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
poutykać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
poutykać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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łęsać się: _: : perf: subj{np(str)} + {xp(locat)}
powałęsać się: _: : perf: subj{np(str)} + {xp(perl)}
powariować: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
powariować: _: : perf: subj{np(str)} + {prepnp(od,gen)}
powariować: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powariować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
powarkiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
powarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
powarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
powarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
powarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
powarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
powarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
powarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
powarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
powarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
powarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
powaśnić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
powaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
poważać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
poważać się: _: : imperf: subj{np(str)} + {cp(żeby)}
poważać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
poważać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
poważać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
poważnieć: _: : imperf: subj{np(str)} + {np(dat)}
poważyć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
poważyć się: _: : perf: subj{np(str)} + {cp(żeby)}
poważyć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
poważyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
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)}
powbijać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
powbijać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,_,'głowa',atr)}
powbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
powbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {preplexnp(do,gen,_,'głowa',atr)}
powbijać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
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)}
powciskać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
powciskać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powciskać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
powciskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(perl)}
powciskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
powciskać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'decha',natr)}
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}
powetować: _: : perf: subj{np(str)} + {np(inst)} + {np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,_,'siebie',natr)}
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)}
powęszyć: _: : perf: subj{np(str)} + {cp(int)}
powęszyć: _: : perf: subj{np(str)} + {np(inst)}
powęszyć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
powęszyć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(locat)}
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)}
powiedzieć: _: : perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{np(nom)}
powiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {cp(że)}
powiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {or}
powiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
powiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {ncp(str,że)}
powiedzieć: _: : perf: subj{np(str)} + obj{cp(int)} + {prepnp(do,gen)}
powiedzieć: _: : perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(do,gen)}
powiedzieć: _: : perf: subj{np(str)} + obj{cp(że)} + {prepnp(do,gen)} + {prepnp(o,loc)}
powiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
powiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
powiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
powiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
powiedzieć: _: : perf: subj{np(str)} + obj{or} + {np(dat)} + {prepnp(o,loc)}
powiedzieć: _: : perf: subj{np(str)} + obj{or} + {prepnp(do,gen)} + {comprepnp(na temat)}
powiedzieć: _: : perf: subj{np(str)} + obj{or} + {prepnp(do,gen)} + {prepnp(o,loc)}
powiedzieć: _: : perf: subj{np(str)} + obj{prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
powiedzieć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepncp(o,loc,że)}
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)}
powiercić się: _: : perf: subj{np(str)} + {xp(locat)}
powiercić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
powiercić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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}
powiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
powiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
powiesić: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {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(_)}
powinszować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
powinszować: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
powinszować: _: : perf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
powinszować: _: : perf: subj{np(str)} + {np(dat)} + {or}
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)}
powkładać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
powłazić: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
powłazić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powłóczyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
powłóczyć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
powłóczyć: _: : imperf: subj{np(str)} + {np(inst)}
powłóczyć: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
powpadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
powpadać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
powpadać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
powpadać: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
powpadać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powpinać się: _: : perf: subj{np(str)}
powpinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
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)}
powróżyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
powróżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
powróżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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}
powrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
powsadzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
powschodzić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
powschodzić: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
powschodzić: _: : perf: subj{np(str)} + {xp(abl)}
powschodzić: _: : perf: subj{np(str)} + {xp(locat)}
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)}
powstawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
powszednieć: _: : imperf: subj{cp(int)} + {np(dat)}
powszednieć: _: : imperf: subj{cp(że)} + {np(dat)}
powszednieć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
powściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
powściągać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
powściągać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
powściągać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
powściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
powściągnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
powściągnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
powściągnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
powściekać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
powściekać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powściekać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
powściekać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
powściekać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {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)}
powtykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
powybierać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
powybierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powybierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powybierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
powybierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powybierać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
powybierać: _: : perf: subj{np(str)} + {prepnp(między,inst)}
powybijać się: _: : perf: subj{np(str)}
powybijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
powychodzić: _: : perf: {prepadjp(na,acc)}
powychodzić: _: : perf: {prepncp(na,acc,że)}
powychodzić: _: : perf: {prepnp(na,acc)}
powychodzić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen)}
powychodzić: _: : perf: subj,controller{np(str); ncp(str,że)} + controllee{prepadjp(na,acc)} + {np(dat)}
powychodzić: _: : perf: subj{cp(że)} + {advp(misc)}
powychodzić: _: : perf: subj{cp(że)} + {np(dat)} + {prepadjp(na,acc)}
powychodzić: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
powychodzić: _: : perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
powychodzić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'bok',natr)}
powychodzić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepadjp(na,acc)}
powychodzić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(na,acc,sg,'zdrowie',natr)}
powychodzić: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(z,gen)}
powychodzić: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
powychodzić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,_,'ucho',natr)}
powychodzić: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'korzyść',natr)}
powychodzić: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powychodzić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
powychodzić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
powychodzić: _: : perf: subj{np(str)} + {prepnp(od,gen)}
powychodzić: _: : perf: subj{np(str)} + {prepnp(poza,acc)}
powychodzić: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
powychylać się: _: : perf: subj{np(str)} + {xp(abl)}
powychylać się: _: : perf: subj{np(str)} + {xp(adl)}
powychylać się: _: : perf: subj{np(str)} + {xp(perl)}
powychylać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powychylać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
powychylać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
powychylać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
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)}
powycierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
powycierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
powycierać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
powycierać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
powycierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
powycierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
powycierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
powycierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepnp(w,acc)} + {prepnp(z,gen)}
powycierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
powycierać: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
powycierać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
powycierać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
powydzierać się: _: : perf: {np(dat)}
powydzierać się: _: : perf: subj{np(str)}
powydzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powydzierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,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)}
powyginać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
powyginać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
powyginać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
powyginać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powyginać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powyginać: _: : perf: {np(str)} + {prepnp(z,gen)}
powyginać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
powyginać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
powyginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powyginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
powyginać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
powyjeżdżać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
powyjeżdżać: _: : perf: subj{np(str)} + obj{np(str)}
powyjeżdżać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
powyjeżdżać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
powyjeżdżać: _: : perf: subj{np(str)} + {xp(abl)}
powyjeżdżać: _: : perf: subj{np(str)} + {xp(adl)}
powyjmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
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)}
powyłazić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
powyłazić: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powymieniać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
powymieniać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
powymieniać: _: : perf: subj{np(str)} + {cp(int)}
powymieniać: _: : perf: subj{np(str)} + {cp(że)}
powymieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {np(dat)}
powymieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(dat)}
powymieniać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'imię',atr); preplexnp(z,gen,sg,'nazwisko',atr)}
powymieniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
powymierać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)} + {lexnp(inst,sg,'śmierć',atr)}
powymierać: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
powymierać: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
powymyślać: _: : perf: subj{np(str)} + {cp(int)}
powymyślać: _: : perf: subj{np(str)} + {cp(że)}
powymyślać: _: : perf: subj{np(str)} + {cp(żeby)}
powymyślać: _: : perf: subj{np(str)} + {np(dat)} + {or}
powymyślać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
powymyślać: _: : perf: subj{np(str)} + obj{np(str)}
powymyślać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
powymywać się: _: : perf: subj{np(str)} + {xp(abl)}
powymywać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
powymywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powymywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
powymywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
powymywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powymywać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
powymywać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
powynosić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
powynosić: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
powynosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powynosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powynosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powynosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
powypadać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
powypalać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
powypalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
powypisywać: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
powypisywać: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
powypisywać: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
powypisywać: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
powypisywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
powypisywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
powypisywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
powypisywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powypisywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
powypisywać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
powypisywać: _: : perf: subj{np(str)} + {xp(abl)} + {refl}
powyprawiać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powyprawiać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
powyprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powyprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powyprawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
powypychać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
powypychać się: _: : perf: subj{np(str)} + {xp(locat)}
powypychać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powypychać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
powypychać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
powypychać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
powyrastać: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,loc)}
powyrastać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
powyrastać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
powyrastać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
powyrastać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
powyrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powyrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
powyrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powyrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
powyrzucać: _: : perf: {np(dat)} + {np(str)}
powyrzucać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
powyrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)} + {xp(adl)}
powyrzucać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)}
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)}
powystawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powystawiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powystawiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
powystrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powystrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powystrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
powystrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
powystrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
powystrzelać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
powystrzelać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)} + {refl}
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)}
powysychać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
powysychać: _: : perf: subj{np(str)} + {xp(locat)}
powysyłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
powysyłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
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)}
powywalać: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('na zbity pysk')}
powywalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powywalać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
powywieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
powywieszać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
powywieszać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
powywlekać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
powywlekać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(perl)}
powywlekać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(perl)}
powywlekać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(abl)}
powywlekać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(adl)}
powywlekać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {refl}
powywlekać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(perl)} + {refl}
powywlekać: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)} + {refl}
powywozić: _: : perf: subj{np(str)} + obj{cp(int)} + {xp(adl)}
powywozić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,pl,'taczka',natr)}
powywozić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
powywracać się: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,pl,'noga',natr)} + {preplexnp(do,gen,sg,'góra',natr)}
powywracać: _: : perf: subj{np(str)} + {lexnp(inst,pl,'oko',atr)}
powywracać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,pl,'noga',natr)} + {preplexnp(do,gen,sg,'góra',natr)}
powywracać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
powyżerać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
powyżerać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powyżerać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
powzdychać: _: : perf: subj{np(str)} + {cp(że)}
powzdychać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
powziąć: _: : perf: subj{np(str)} + obj{np(str)}
powznosić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
powznosić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
powznosić się: _: : perf: subj{np(str)} + {prepnp(ponad,acc)}
powznosić się: _: : perf: subj{np(str)} + {xp(locat)}
powznosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozabierać się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
pozabierać się: _: : perf: subj{np(str)} + {xp(abl)}
pozabierać się: _: : perf: subj{np(str)} + {xp(adl)}
pozabierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pozabierać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozabierać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozabijać się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
pozabijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozachodzić: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
pozachodzić: _: : perf: subj{np(str)} + {np(inst)}
pozachodzić: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
pozachodzić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
pozachodzić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pozachwycać się: _: : perf: subj{np(str)} + {cp(gdy)}
pozachwycać się: _: : perf: subj{np(str)} + {cp(int)}
pozachwycać się: _: : perf: subj{np(str)} + {cp(jak)}
pozachwycać się: _: : perf: subj{np(str)} + {cp(jeśli)}
pozachwycać się: _: : perf: subj{np(str)} + {cp(że)}
pozachwycać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pozachwycać się: _: : perf: subj{np(str)} + {or}
pozachwycać się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
pozachwycać: _: : perf: subj{cp(int)} + {np(str)}
pozachwycać: _: : perf: subj{cp(jak)} + {np(str)}
pozachwycać: _: : perf: subj{cp(kiedy)} + {np(str)}
pozachwycać: _: : perf: subj{cp(że)} + {np(str)}
pozachwycać: _: : perf: subj{ncp(str,int)} + {np(str)}
pozachwycać: _: : perf: subj{ncp(str,że)} + {np(str)}
pozachwycać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pozaciągać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pozaciągać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozaciągać się: _: : perf: subj{np(str)} + {np(inst)}
pozaciągać się: _: : perf: subj{np(str)} + {xp(adl)}
pozaciągać się: _: : perf: subj{np(str)} + {xp(locat)}
pozaciągać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
pozaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pozaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozaciągać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozacierać się: _: : perf: subj{np(str)} + {np(dat)}
pozacierać: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
pozaginać się: _: : perf: subj{np(str)} + {np(dat)}
pozaginać się: _: : perf: subj{np(str)} + {xp(locat)}
pozaginać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pozaginać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozaglądać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
pozagryzać się: _: : perf: subj{np(str)}
pozagryzać: _: : perf: subj{np(str)} + obj{np(str)}
pozajmować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
pozajmować: _: : perf: subj{np(str)} + obj{lexnp(str,_,'miejsce',atr)} + {np(dat)} + {prepnp(w,loc)}
pozajmować: _: : perf: subj{np(str)} + obj{lexnp(str,_,'pozycja',atr)} + {prepnp(w,loc)}
pozajmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pozajmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozaklejać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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)}
pozakopywać się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
pozakopywać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pozakopywać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pozakopywać się: _: : perf: subj{np(str)} + {xp(locat)}
pozakopywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozakopywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
pozalewać się: _: : perf: subj{np(str)} + {np(inst)}
pozalewać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pozalewać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozałatwiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
pozałatwiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {preplexnp(od,gen,sg,'ręka',natr)}
pozamarzać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozamarzać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
pozamieniać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pozamieniać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
pozamieniać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pozamieniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozamieniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozamieniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pozamykać się: _: : perf: subj{np(str)} + {np(dat)}
pozamykać się: _: : perf: subj{np(str)} + {preplexnp(przed,inst,_,'nos',ratr)}
pozamykać się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
pozamykać się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(w,loc)}
pozamykać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
pozamykać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozamykać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
pozamykać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pozapalać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
pozapalać się: _: : perf: subj{np(str)} + {np(inst)}
pozapalać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pozapalać się: _: : perf: subj{np(str)} + {xp(locat)}
pozapalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozapalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozapalać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pozapinać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
pozapinać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
pozapinać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pozapinać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozapinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozapinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pozapinać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozapinać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozapinać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
pozapinać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pozapinać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
pozapisywać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozapisywać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pozapisywać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pozapisywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pozapisywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozapisywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozapisywać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
pozapominać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
pozapominać: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
pozapominać: _: : perf: subj{np(str)} + {cp(int)}
pozapominać: _: : perf: subj{np(str)} + {cp(jak)}
pozapominać: _: : perf: subj{np(str)} + {cp(że)}
pozapominać: _: : perf: subj{np(str)} + {cp(żeby)}
pozapominać: _: : perf: subj{np(str)} + {np(gen)}
pozapominać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)}
pozapominać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pozaprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozaprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozaprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozaprowadzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
pozapychać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pozapychać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozapychać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozarastać się: _: : perf: subj{np(str)} + {np(dat)}
pozarastać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pozarastać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
pozasłaniać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
pozasłaniać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
pozasłaniać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
pozasłaniać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
pozastawiać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
pozastawiać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
pozastawiać się: _: : perf: subj{np(str)} + {xp(locat)}
pozastawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
pozastawiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
pozastawiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozasuwać się: _: : perf: subj{np(str)} + {np(inst)}
pozasuwać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
pozasuwać się: _: : perf: subj{np(str)} + {xp(adl)}
pozasuwać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
pozasuwać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pozasuwać: _: : perf: subj{np(str)} + {np(dat)} + {or}
pozasuwać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
pozasuwać: _: : perf: subj{np(str)} + {np(inst)}
pozasuwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozasuwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
pozasuwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
pozasuwać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozasuwać: _: : perf: subj{np(str)} + {prepadjp(po,postp)}
pozasuwać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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}
pozaszywać się: _: : perf: subj{np(str)} + {xp(adl)}
pozaszywać się: _: : perf: subj{np(str)} + {xp(locat)}
pozaszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozaszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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}
pozatykać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pozatykać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozatykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozatykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozatykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pozatykać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,pl,'ucho',atr)}
pozawalać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
pozawalać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pozawalać się: _: : perf: subj{np(str)} + {xp(adl)}
pozawalać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
pozawierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pozawieszać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pozawieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozawieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozawieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pozawieszać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pozawieszać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
pozawijać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozawijać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pozawijać się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
pozawijać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pozawijać się: _: : perf: subj{np(str)} + {xp(locat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
pozawijać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
pozawijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozawijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pozawijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozawijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
pozawijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozawijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pozawijać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozawozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozawracać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
pozawracać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)} + {np(str)}
pozawracać: _: : perf: subj{np(str)} + {np(dat)} + {np(str)} + {comprepnp(w sprawie)}
pozawracać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
pozawracać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozawracać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
pozbijać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pozbijać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozbijać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozbyć się: _: : perf: subj{np(str)} + {np(gen)} + {xp(abl)}
pozbywać się: _: : imperf: subj{np(str)} + {np(gen)} + {xp(abl)}
pozdawać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
pozdawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pozdawać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozdawać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozdejmować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
pozdrapywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {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)}
pozdrowić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pozdrowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozdrowić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
pozdrowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozdrowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pozdrowić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozdychać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
pozdychać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozdychać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozdychać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pozdychać: _: : perf: subj{np(str)} + {prepnp(za,acc)}
pozdzierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pozdzierać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
pozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
pozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
pozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
pozdzierać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
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)}
pozielenieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pozielenieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozielenieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pozielenieć: _: : perf: subj{np(str)} + {xp(locat)}
poziewać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
poziewać: _: : perf: subj{np(str)} + {xp(dur)}
pozjadać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
pozjadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozjadać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(str,pl,'ząb',natr)}
pozjeżdżać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
pozjeżdżać: _: : perf: {np(gen)} + {np(inst)} + {xp(abl)} + {xp(adl)}
pozjeżdżać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
pozjeżdżać: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
pozjeżdżać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
pozjeżdżać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
pozjeżdżać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
pozjeżdżać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
pozlepiać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
pozlepiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pozlepiać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
pozlepiać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pozlepiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozlepiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozlepiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pozłacać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozłazić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozłazić się: _: : perf: subj{np(str)} + {xp(locat)}
pozłazić: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
pozmieniać się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {prepadjp(z,gen)}
pozmieniać się: _: : perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + {prepadjp(z,gen)}
pozmieniać się: _: : perf: subj{np(str)} + {np(dat)}
pozmieniać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
pozmieniać się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
pozmieniać się: _: : perf: subj{np(str)} + {xp(locat)}
pozmieniać się: _: : perf: subj{np(str)} + {xp(mod)}
pozmieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
pozmieniać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)}
pozmieniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozmieniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pozmieniać: _: : perf: subj{np(str)} + {xp(locat)}
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)}
poznikać: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
poznikać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
poznosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poznosić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozorować: _: : imperf: subj{np(str)} + obj{cp(że)}
pozorować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
pozrywać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
pozrywać się: _: : perf: subj{np(str)} + {xp(abl)}
pozrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
pozrywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
pozrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozrywać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pozrywać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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)}
pozszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
pozszywać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,inst)}
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)}
pozwalniać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pozwalniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pozwalniać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
pozwieszać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pozwieszać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
pozwieszać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozwieszać: _: : perf: subj{np(str)} + {lexnp(str,_,'nos',natr)} + {preplexnp(na,acc,sg,'kwinta',natr)}
pozwieszać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
pozwieszać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pozwijać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pozwijać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pozwijać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
pozwijać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
pozwijać się: _: : perf: subj{np(str)} + {xp(abl)}
pozwijać się: _: : perf: subj{np(str)} + {xp(adl)}
pozwijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pozwijać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozwijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozwijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pozwijać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
pozwozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozwozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pozwozić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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żartować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
pożartować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)} + {or}
pożartować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {lexnp(dat,_,'siebie',natr)}
pożartować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
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)}
prać się: _: : imperf: subj{np(str)}
prać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
prać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
prać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
prać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
prać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
prać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
prać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
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)}
prefabrykować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
prezesować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(dur)}
prezesować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
prezesować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
prezesować: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
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)}
procentować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
procentować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
procentować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
procentować: _: : imperf: subj{np(str)} + {xp(locat)}
procentować: _: : imperf: subj{np(str)} + {xp(mod)}
procesować się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
procesować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
procesować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
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)}
profanować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
prolongować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
prolongować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
prolongować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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}
prostytuować się: _: : imperf: subj{np(str)} + {advp(misc)}
prostytuować: _: : imperf: subj{np(str)} + {np(str)}
protegować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
protegować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
protegować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
protegować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
protegować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
protegować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
protokołować: _: : imperf: subj{np(str)} + {cp(że)}
protokołować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
prowadzać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
prowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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óżniaczyć się: _: : imperf: subj{np(str)}
próżniaczyć: _: : imperf: subj{np(str)}
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)}
prząść: _: : imperf: controller{np(str)} + controllee{xp(mod)}
prząść: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
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)}
przebiedować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
przebiedować: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
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)}
przebłagać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
przebłyskiwać: _: : imperf: subj{cp(że)} + {np(dat)}
przebłyskiwać: _: : imperf: subj{np(str)} + {np(dat)}
przebłyskiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(między,inst)}
przebłyskiwać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przebłyskiwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
przebłyskiwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
przeboleć: _: : perf: subj{np(str)} + {cp(int)}
przeboleć: _: : perf: subj{np(str)} + {cp(że)}
przeboleć: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
przebóść: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przebóść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
przebudowywać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przebudowywać się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przebudowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przebudowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebudowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przebudowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przebudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przebudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebudzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przebudzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
przebudzać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
przebudzać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
przebudzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przebudzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
przebudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przebudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przebudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
przebudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {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)}
przebyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(dur)} + {xp(locat)}
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}
przechadzać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
przechadzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przechłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przechłodzić: _: : 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)}
przechwalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przechwalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
przechwalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przechwalić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
przechwalić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
przechwalić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)} + {prepnp(przed,inst)}
przechwalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
przechwalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(jak)}
przechwalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
przechwalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
przechwalić: _: : perf: 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)}
przechytrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przechytrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przechytrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,sg,'pomoc',natr)}
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)}
przeciec: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeciekać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
przeciwić się: _: : imperf: subj{np(str)} + {np(dat)} + {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)}
przeczołgać się: _: : perf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeczołgać: _: : perf: subj{np(str)} + obj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeczuć: _: : perf: subj{np(str)} + {cp(int)}
przeczuć: _: : perf: subj{np(str)} + {cp(że)}
przeczuć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przeczuwać: _: : imperf: subj{np(str)} + {cp(int)}
przeczuwać: _: : imperf: subj{np(str)} + {cp(że)}
przeczuwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
przedefilować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(przed,inst)}
przedefilować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedefilować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
przedefilować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(perl)}
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)}
przedmuchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przedmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przedobrzyć: _: : perf: subj{np(str)} + {np(str)}
przedobrzyć: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
przedobrzyć: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
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)}
przedrukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
przedrukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przedrukować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przedrukować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przedrukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przedrukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przedrukowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
przedrzemać się: _: : perf: subj{np(str)} + {xp(locat)}
przedrzemać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
przedzielać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
przedzielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przedzielić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
przedzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
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)}
przedzierzgnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przedzierzgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przedziurawić się: _: : perf: subj{np(str)}
przedziurawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przedzwonić: _: : perf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
przedzwonić: _: : perf: subj{np(str)} + {cp(int); cp(że); cp(żeby)} + {xp(abl)} + {xp(adl)}
przedzwonić: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)}
przedzwonić: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)}
przedzwonić: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {xp(abl)} + {xp(adl)}
przeegzaminować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeegzaminować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
przeegzaminować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przefarbować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {refl}
przefarbować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
przefarbować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przefarbować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przefarbować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przefarbować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {refl}
przefiltrować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przefiltrować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przefiltrować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przefiltrować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przefiltrować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przefiltrować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
przefiltrować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przefiltrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przeformułować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
przeformułować: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(na,acc)} + {prepadjp(z,gen)}
przeformułować: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(w,acc)} + {prepadjp(z,gen)}
przeformułować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeformułować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
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)}
przefrunąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przefrunąć: _: : perf: subj{np(str)} + {xp(mod)} + {xp(perl)}
przegadać: _: : perf: subj{np(str)} + obj{np(str)}
przegadać: _: : perf: subj{np(str)} + {xp(dur)}
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)}
przegiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
przegiąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przegiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przegiąć: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
przeginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
przeginać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przeginać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przeginać: _: : imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
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)}
przeglądnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przeglądnąć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
przegłosowywać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(int)}
przegłosowywać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
przegłosowywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(inst)}
przegłosowywać: _: : imperf: 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)}
przegnić: _: : perf: subj{np(str)} + {xp(locat)}
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)}
przegradzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
przegradzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
przegrodzić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
przegrodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
przegrupować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
przegrupować się: _: : perf: subj{np(str)} + {xp(adl)} + {xp(adl)}
przegrupować się: _: : perf: subj{np(str)} + {xp(locat)}
przegrupować się: _: : perf: subj{np(str)} + {xp(mod)}
przegrupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przegrupować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przegrupować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przegrupować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
przegrupowywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
przegrupowywać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(adl)}
przegrupowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
przegrupowywać się: _: : imperf: subj{np(str)} + {xp(mod)}
przegrupowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przegrupowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przegrupowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przegrupowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
przeholować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przeholować: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
przeholować: _: : perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
przehulać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przehulać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przehulać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
przejadać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przejadać się: _: : imperf: subj{np(str)} + {np(inst)}
przejadać: _: : imperf: subj{np(str)}
przejaskrawiać: _: : imperf: subj{np(str)} + {cp(że)}
przejaskrawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
przejaskrawić: _: : perf: subj{np(str)} + {cp(że)}
przejaskrawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
przejaśniać się: _: : imperf: {np(dat)} + {xp(locat)}
przejaśniać się: _: : imperf: subj{np(str)} + {np(dat)}
przejaśniać: _: : imperf: subj{E} + {xp(locat)}
przejaśniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przejaśnić się: _: : perf: {np(dat)} + {comprepnp(w kwestii)}
przejaśnić się: _: : perf: {np(dat)} + {xp(locat)}
przejaśnić się: _: : perf: subj{np(str)} + {np(dat)}
przejaśnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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ść się: _: : perf: {np(dat)} + {cp(że)}
przejeść się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przejeść się: _: : perf: subj{np(str)} + {np(inst)}
przejeść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
przejęzyczyć się: _: : perf: subj{np(str)} + {or}
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)}
przekabacić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
przekabacić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przekabacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przekabacić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przekartkować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
przekąsić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przekąsić: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,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}
przekładać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
przekładać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekładać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przekładać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przekłuć się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przekłuć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przekłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przekłuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przekłuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przekłuwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przekłuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przekomarzać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
przekomarzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
przekomarzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
przekomarzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
przekomarzać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {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)}
przekonsultować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
przekonsultować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
przekonsultować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
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}
przekopać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekopać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
przekopać się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przekopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przekopiować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przekopiować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przekopiować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)}
przekopiować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {refl}
przekopywać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekopywać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
przekopywać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przekopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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}
przekrzywiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
przekrzywiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przekrzywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przekrzywić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
przekrzywić się: _: : perf: subj{np(str)} + {xp(locat)}
przekrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przekrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
przekuć się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,acc)}
przekuć się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,acc)}
przekuć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekuć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
przekuć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przekuć się: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
przekuć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,acc)}
przekuć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,acc)}
przekuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przekuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przekuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
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)}
przekuwać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,acc)}
przekuwać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,acc)}
przekuwać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekuwać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
przekuwać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przekuwać się: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
przekuwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,acc)}
przekuwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,acc)}
przekuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przekuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przekuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przekuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,ż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)}
przekwaterować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przekwaterować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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źć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przeleźć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeleżeć: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przelęknąć się: _: : perf: subj{np(str)} + {cp(int)}
przelęknąć się: _: : perf: subj{np(str)} + {cp(że)}
przelęknąć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przelęknąć się: _: : perf: subj{np(str)} + {np(inst)}
przelęknąć: _: : perf: subj{np(str)} + {np(str)}
przelicytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
przelicytować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przelicytowywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {refl}
przelicytowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
przelicytowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
przelicytowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przelicytowywać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
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łazić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przełazić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przełączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przełączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przełączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przełączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przełączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przełączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przełączać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {refl}
przełączać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)} + {refl}
przełączać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {refl}
przełączać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przełączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przełączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przełączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przełączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przełączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przełączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przełączyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)} + {refl}
przełączyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)} + {refl}
przełączyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {refl}
przełączyć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przełknąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
przełożyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przełożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przełożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przełożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przełożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przełykać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
przemagać się: _: : imperf: subj{np(str)} + {cp(żeby)}
przemagać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przemagać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przemagać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przemagać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,_,'siebie',natr)}
przemagać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
przemalować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
przemalować się: _: : perf: subj{np(str)} + {advp(misc)}
przemalować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
przemalować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
przemalowywać: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {refl}
przemalowywać: _: : imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {refl}
przemalowywać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
przemalowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemalowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
przemalowywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przemarzać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przemarzać: _: : imperf: subj{np(str)} + {xp(adl)}
przemarznąć: _: : perf: subj{np(str)} + {fixed('do głębi')}
przemarznąć: _: : perf: subj{np(str)} + {fixed('do szczętu')}
przemarznąć: _: : perf: subj{np(str)} + {fixed('do szpiku kości')}
przemarznąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przemarznąć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'kość',natr)}
przemarznąć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'lód',natr)}
przemarznąć: _: : perf: subj{np(str)} + {xp(adl)}
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)}
przemeblować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
przemierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {fixed('wzdłuż i wszerz')}
przemierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(dur)}
przemierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przemierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('wzdłuż i wszerz')}
przemierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)} + {xp(temp)}
przemierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {xp(abl)} + {xp(mod)} + {xp(perl)}
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)}
przemieścić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przemieścić się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(adl)}
przemieścić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przemieścić się: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
przemieścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
przemieścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przemieścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {xp(adl)}
przemieścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przemieścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przemieścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
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)}
przemknąć: _: : perf: subj{cp(że)} + {np(dat)} + {prepnp(przez,acc)}
przemknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przemknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przemknąć: _: : perf: subj{or} + {np(dat)} + {prepnp(przez,acc)}
przemnożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przemnożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przemoczyć się: _: : perf: subj{np(str)} + {np(dat)}
przemoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przemoknąć: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
przemoknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przemoknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przemoknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
przemycać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
przemycać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przemycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przemycać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
przemycać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przemycać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przemycić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przemycić się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
przemycić się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przemycić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przemycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przemycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
przemycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przemycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przemyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przemykać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(dur)} + {xp(locat)}
przemykać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {xp(locat)} + {or}
przemykać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przemykać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(mod)} + {xp(perl)}
przemykać: _: : imperf: subj{or} + {np(dat)} + {prepnp(przez,acc)}
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)}
przemyśliwać: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
przemyśliwać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
przemyśliwać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przemywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przemywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przemywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przenicować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przenicować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przenicować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przenicować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'strona',ratr)}
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)}
przeorać się: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przeorać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przeorać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przeorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeorać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przeorientować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {advp(misc)}
przeorientować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przeorientować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {advp(misc)}
przeorientować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
przepakować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przepakować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przepakowywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przepakowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przepalać się: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
przepalać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
przepalać się: _: : imperf: subj{np(str)} + {prepnp(wskutek,gen)}
przepalać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
przepalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przepalać: _: : imperf: subj{np(str)} + {xp(locat)}
przepalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przepalić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przepalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przepalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przepalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przepalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przepasać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
przepasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
przepatrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
przepić się: _: : perf: subj{np(str)}
przepić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przepijać się: _: : imperf: subj{np(str)}
przepijać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przepijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przepijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przepiłować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przepiłować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przepiłować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
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łacać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
przepłacać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
przepłacić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
przepłacić: _: : perf: subj{np(str)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
przepłakać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przepłakać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przepłakać: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przepłoszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przepłukać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przepłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przepłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przepłukiwać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przepłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przepłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
przepocić się: _: : perf: subj{np(str)}
przepocić: _: : perf: subj{np(str)} + obj{np(str)}
przepoić się: _: : perf: subj{np(str)} + {np(inst)}
przepoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
przepompować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepompowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
przeprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przeprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeprać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przeprać: _: : perf: 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)}
przeprawiać się: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc); advp(misc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeprawiać się: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {xp(locat)}
przeprawiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)} + {np(inst)}
przeprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(locat)}
przeprawić się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeprawić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)} + {np(inst)}
przeprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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}
przeprowadzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przeprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przeprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przeprowadzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzić się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przeprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przeprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przeprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
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)}
przerąbać się: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przerąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {fixed('na pół')}
przerąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
przeredagować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przeredagować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeredagować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
przerejestrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przerejestrować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {refl}
przereklamować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
przerzedzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przerzedzać się: _: : imperf: {xp(locat)}
przerzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przerzedzić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przerzedzić się: _: : perf: {xp(locat)}
przerzedzić: _: : perf: 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ączać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesączać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesączyć się: _: : perf: subj{np(str)} + {np(inst)}
przesączyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesączyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
przesiedlać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiedlać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesiedlić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiedlić: _: : perf: subj{np(str)} + obj{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)}
przesilać się: _: : imperf: subj{np(str)} + {advp(misc)}
przesilać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
przesilać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przesilić się: _: : perf: subj{np(str)} + {advp(misc)}
przesilić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przeskakiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przeskakiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeskakiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przeskakiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeskakiwać: _: : imperf: subj{np(str)} + {prepnp(przez,acc)}
przeskakiwać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeskakiwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeskalować się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
przeskalować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przeskalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przeskalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeskoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przeskoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeskoczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przeskoczyć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przeskoczyć: _: : perf: subj{np(str)} + {prepnp(przez,acc)}
przeskoczyć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeskoczyć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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łodzić się: _: : perf: subj{np(str)} + {np(inst)}
przesłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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)}
przesolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przespacerować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przespacerować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(perl)}
przespacerować: _: : perf: subj{np(str)} + obj{np(str)}
przespacerować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
przestrajać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestrajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przestrajać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {refl}
przestraszać się: _: : imperf: subj{np(str)} + {cp(int)}
przestraszać się: _: : imperf: subj{np(str)} + {cp(że)}
przestraszać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przestraszać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przestraszać: _: : imperf: subj{cp(że)} + {np(str)}
przestraszać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
przestraszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)}
przestroić się: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {advp(misc)}
przestroić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
przestroić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
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)}
przestudzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przestudzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
przestudzić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
przestudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
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)}
przesuszyć się: _: : perf: subj{np(str)}
przesuszyć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
przesypać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesypać się: _: : perf: subj{np(str)} + {xp(perl)}
przesypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesypać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesypać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
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)}
przesypywać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeszacować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
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)}
przeszkolić się: _: : perf: subj{np(str)} + {cp(int)}
przeszkolić się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)}
przeszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
przeszkolić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)}
przeszmuglować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
przetańczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przetapiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetapiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetapiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przetapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przetapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
przetasować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przetasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przetasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
przetopić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przetopić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetopić się: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetopić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przetopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przetopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przetopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
przetransferować się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetransferować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetransponować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przetransponować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przetransponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)} + {xp(perl)}
przetransponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetransponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
przetransponować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przetransponować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {refl}
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)}
przetrawiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
przetrawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
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)}
przetrzebić: _: : 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)}
przewalutować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
przewartościować się: _: : perf: subj{np(str)} + {np(dat)}
przewartościować się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
przewartościować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przewartościować się: _: : perf: subj{np(str)} + {xp(adl)}
przewartościować się: _: : perf: subj{np(str)} + {xp(locat)}
przewartościować: _: : perf: subj{np(str)} + obj{np(str)}
przewartościować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przewartościować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przewartościować: _: : perf: subj{np(str)} + {refl}
przewartościowywać się: _: : imperf: subj{np(str)} + {np(dat)}
przewartościowywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
przewartościowywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przewartościowywać się: _: : imperf: subj{np(str)} + {xp(adl)}
przewartościowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
przewartościowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przewartościowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przewartościowywać: _: : imperf: subj{np(str)} + {refl}
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)}
przewędrować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(str)} + {xp(abl)} + {xp(adl)}
przewędrować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(perl)}
przewędrować: _: : perf: subj{np(str)} + {np(str)} + {cp(żeby)}
przewędrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przewędrować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przewiać: _: : perf: {np(dat)} + {np(str)}
przewiać: _: : perf: {np(str)} + {xp(adl)}
przewiać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
przewiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
przezierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(perl)}
przezierać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(perl)}
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)}
przyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',atr)}
przyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
przyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
przyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
przybłąkać się: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
przybłąkać się: _: : perf: subj{np(str)} + {xp(abl)}
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}
przybrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
przybrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przybrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przybrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
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)}
przychwycić się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
przychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
przychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przychwycić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
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)}
przyciemniać się: _: : imperf: subj{np(str)}
przyciemniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyciemnić się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
przyciemnić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przyciemnić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
przyciemnić się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
przyciemnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
przyciszyć się: _: : perf: {xp(locat)}
przyciszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przycumować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
przycumować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przycumować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przycupnąć: _: : perf: subj{np(str)} + {xp(locat)}
przyczaić się: _: : perf: subj{np(str)} + {cp(żeby)}
przyczaić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przyczaić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {xp(locat)}
przyczaić się: _: : perf: subj{np(str)} + {xp(abl)}
przyczajać się: _: : imperf: subj{np(str)} + {cp(żeby)}
przyczajać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przyczajać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {xp(locat)}
przyczajać się: _: : imperf: subj{np(str)} + {xp(abl)}
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)}
przyćmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyćmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przyćmiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyćmiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
przydepnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przydeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przydeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przydusić się: _: : perf: subj{np(str)} + {np(inst)}
przydusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przydusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
przyduszać się: _: : imperf: subj{np(str)} + {np(inst)}
przyduszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyduszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
przydybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przydybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
przydybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przydybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przydybać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przydybać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
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)}
przydźwigać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
przydźwigać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
przyfrunąć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
przyfrunąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przygadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przygadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
przygadać: _: : perf: subj{np(str)} + {np(dat)} + {or}
przygadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
przygadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przygadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przygadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
przygadywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przygadywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
przygadywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
przygarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przygarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przygarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przygarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przygarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przygarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przygarniać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przygasać: _: : imperf: subj{np(str)}
przygasić się: _: : perf: subj{np(str)}
przygasić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
przygasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,jak); ncp(inst,że)}
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)}
przyglądnąć się: _: : perf: subj{np(str)} + {cp(jak)}
przyglądnąć się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyglądnąć się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przygładzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przygładzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
przygnębiać: _: : imperf: subj{cp(gdy)} + {np(str)}
przygnębiać: _: : imperf: subj{cp(int)} + {np(str)}
przygnębiać: _: : imperf: subj{cp(jak)} + {np(str)}
przygnębiać: _: : imperf: subj{cp(kiedy)} + {np(str)}
przygnębiać: _: : imperf: subj{cp(że)} + {np(str)}
przygnębiać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
przygnębiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
przygnębić: _: : perf: subj{cp(gdy)} + {np(str)}
przygnębić: _: : perf: subj{cp(int)} + {np(str)}
przygnębić: _: : perf: subj{cp(jak)} + {np(str)}
przygnębić: _: : perf: subj{cp(kiedy)} + {np(str)}
przygnębić: _: : perf: subj{cp(że)} + {np(str)}
przygnębić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
przygnębić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
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)}
przygrzać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przygrzać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przygrzać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przygrzać: _: : perf: {np(dat)}
przygrzać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przygrzać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
przygrzać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
przygrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przygrzać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przygrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przygrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przygrzewać: _: : imperf: subj{np(str)} + {xp(abl)}
przygrzewać: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
przyhamować: _: : perf: subj{np(str)} + {cp(żeby)}
przyhamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyhamować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
przyjechać: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
przyjechać: _: : perf: subj{np(str)} + {np(inst)}
przyjechać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przyjechać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przyjechać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
przyjechać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
przyjechać: _: : perf: subj{np(str)} + {prepnp(po,acc)}
przyjechać: _: : perf: subj{np(str)} + {prepnp(za,inst)}
przyjechać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przyjechać: _: : perf: subj{np(str)} + {xp(perl)}
przyjeżdżać: _: : imperf: subj{np(str)} + {np(inst)}
przyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
przyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
przyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(po,acc)}
przyjeżdżać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
przyjeżdżać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przyjeżdżać: _: : imperf: subj{np(str)} + {xp(perl)}
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)}
przykazywać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
przykazywać: _: : imperf: subj{np(str)} + {np(dat)} + {advp(pron)}
przykazywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przykazywać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
przykazywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przykazywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyklaskiwać: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
przyklasnąć: _: : perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
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)}
przyklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyklękać: _: : imperf: subj{np(str)} + {cp(żeby)}
przyklękać: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'kolano',atr)}
przyklękać: _: : imperf: subj{np(str)} + {preplexnp(na,loc,sg,'kolano',atr)}
przyklękać: _: : imperf: subj{np(str)} + {xp(locat)}
przyklęknąć: _: : perf: subj{np(str)} + {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)}
przykrawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
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)}
przykroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przykrócić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'cugiel',natr)}
przykrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przykryć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przykryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przykrywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przykrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przykrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
przykrzyć się: _: : imperf: {np(dat)} + {prepnp(za,inst)}
przykrzyć się: _: : imperf: {np(dat)} + {xp(locat)}
przykrzyć się: _: : imperf: subj,controllee{infp(imperf)} + controller{np(dat)}
przykrzyć się: _: : imperf: subj{cp(int)} + {np(dat)}
przykrzyć się: _: : imperf: subj{cp(że)} + {np(dat)}
przykrzyć się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przykrzyć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
przykucać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przykucać: _: : imperf: subj{np(str)} + {xp(locat)}
przykucnąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
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)}
przykurczyć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
przykurczyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
przykurczyć: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
przylać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
przylatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przylatywać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przylatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
przylec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przylecieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)}
przylecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przylecieć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst); prepncp(z,inst,że)}
przylecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,acc)}
przylecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
przylecieć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(abl)}
przylecieć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
przylegać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyległy: : : : {prepnp(do,gen)} + {xp(abl)}
przylepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przylepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
przylepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przylepić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
przyleźć: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyleźć: _: : perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyleźć: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
przyleźć: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyleźć: _: : perf: subj{cp(int)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyleźć: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyleźć: _: : perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyleźć: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyleźć: _: : perf: subj{cp(że)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyleźć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyleźć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyleźć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'świat',natr)}
przyleźć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
przyleźć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
przyleźć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przyleźć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przyleźć: _: : perf: subj{np(str)} + {xp(adl)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
przylgnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przylizać się: _: : perf: subj{np(str)} + {np(dat)}
przylizać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przylizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przylizać: _: : perf: subj{np(str)} + obj{np(str)} + {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łapywać się: _: : imperf: subj{np(str)} + {cp(int)}
przyłapywać się: _: : imperf: subj{np(str)} + {cp(jak)}
przyłapywać się: _: : imperf: subj{np(str)} + {cp(że)}
przyłapywać się: _: : imperf: subj{np(str)} + {cp(żeby2)}
przyłapywać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby2)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przyłapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
przyłazić: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyłazić: _: : imperf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyłazić: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
przyłazić: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyłazić: _: : imperf: subj{cp(int)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyłazić: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyłazić: _: : imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyłazić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyłazić: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyłazić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyłazić: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyłazić: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'świat',natr)}
przyłazić: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
przyłazić: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
przyłazić: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przyłazić: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przyłazić: _: : imperf: subj{np(str)} + {xp(adl)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
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)}
przymarzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przymarznąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przymawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przymawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przymawiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przymawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
przymawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
przymawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
przymawiać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
przymawiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przymawiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przymawiać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
przymglić się: _: : perf: subj{np(str)} + {np(dat)}
przymglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
przymilać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przymilać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
przymilać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przymilać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
przymilić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
przymilić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
przymilić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przymilić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
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)}
przymówić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przymówić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
przymówić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przymówić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
przymówić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
przymówić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
przymówić się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
przymówić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
przymówić: _: : perf: subj{np(str)} + {np(dat)} + {or}
przymówić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
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)}
przynaglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
przynaglać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przynaglać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
przynaglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
przynaglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przynaglić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
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)}
przynudzać: _: : imperf: subj{np(str)} + {cp(int)}
przynudzać: _: : imperf: subj{np(str)} + {cp(jak)}
przynudzać: _: : imperf: subj{np(str)} + {cp(że)}
przynudzać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
przyobiecać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
przyobiecać: _: : perf: subj{np(str)} + {np(dat)} + {or}
przyobiecać: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przyobiecać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przyoblec: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przyoblec: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyoblec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przyoblec: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przyoblekać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przyoblekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyoblekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przyoblekać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przyodziać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {refl}
przyodziać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)} + {refl}
przyodziać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
przyodziać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,acc)}
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)}
przypalać się: _: : imperf: subj{np(str)} + {np(dat)}
przypalać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przypalać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
przypalać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
przypalać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
przypalać się: _: : imperf: subj{np(str)} + {xp(locat)}
przypalać: _: : imperf: subj{np(str)} + {lexnp(str,sg,'głup',natr)}
przypalać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przypalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przypalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przypalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
przypalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
przypalić się: _: : perf: subj{np(str)} + {np(dat)}
przypalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przypalić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
przypalić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
przypalić się: _: : perf: subj{np(str)} + {xp(locat)}
przypalić: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(str,sg,'głup',natr)}
przypalić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przypalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przypalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przypalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przypalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przypasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przypasać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
przypiec się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
przypiec się: _: : perf: subj{np(str)} + {np(dat)}
przypiec się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
przypiec się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
przypiec: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przypiec: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przypiec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przypiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przypiec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przypieczętować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przypiekać się: _: : imperf: subj{np(str)} + {np(dat)}
przypiekać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
przypiekać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
przypiekać się: _: : imperf: subj{np(str)} + {xp(locat)}
przypiekać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przypiekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przypiekać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przypiekać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
przypilnować: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {xp(dur)} + {xp(mod)}
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}
przyplątać się: _: : perf: subj{np(str)} + {np(dat)}
przyplątać się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
przyplątywać się: _: : imperf: subj{np(str)} + {np(dat)}
przyplątywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
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)}
przypochlebiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przypochlebić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
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)}
przypudrować się: _: : perf: subj{np(str)}
przypudrować: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,sg,'siebie',natr)}
przypudrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
przyrastać: _: : imperf: {np(dat)} + {np(gen)}
przyrastać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyrastać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przyrastać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
przyrastać: _: : imperf: subj{np(str)} + {xp(mod)}
przyrosnąć: _: : perf: {np(dat)} + {np(gen)}
przyrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przyrosnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
przyrosnąć: _: : perf: subj{np(str)} + {xp(mod)}
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}
przyrumienić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(na,loc)} + {advp(misc)}
przyrumienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(na,loc)} + {advp(misc)}
przyrumienić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)} + {advp(misc)}
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)}
przyschnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
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)}
przyskoczyć: _: : perf: subj{np(str)} + {xp(adl)}
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łuchać się: _: : perf: subj{np(str)} + {cp(int)}
przysłuchać się: _: : perf: subj{np(str)} + {cp(jak)}
przysłuchać się: _: : perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
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)}
przysmażyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
przysmażyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
przysmażyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przysmażyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przysmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
przysmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przysnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przysnąć: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
przysnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
przysnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
przysnąć: _: : perf: subj{np(str)} + {xp(locat)}
przysparzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(gen)}
przysparzać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przyspawać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {xp(locat)} + {refl}
przyspawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {xp(locat)}
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)}
przysporzyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(gen)}
przysporzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przysposabiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przysposabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przysposobić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przysposobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przyssać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyssać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
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)}
przystopować: _: : perf: {np(str)}
przystopować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przystopować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przystopować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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)}
przysunąć się: _: : perf: subj{np(str)} + {advp(misc)}
przysunąć się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przysunąć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
przysunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
przysuwać się: _: : imperf: subj{np(str)} + {advp(misc)}
przysuwać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przysuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
przysuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
przysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
przysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przysypać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
przysypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przysypiać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
przysypiać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
przysypiać: _: : imperf: subj{np(str)} + {xp(locat)}
przysypywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
przysypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyszpilić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyszpilić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przyszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyszykować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
przyszykować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
przyszykować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przyszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
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)}
przyświecić: _: : perf: subj{np(str)} + {advp(misc)}
przyświecić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
przyświecić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przyświecić: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
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}
przytargać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
przytargać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
przytaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
przytaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
przytępiać się: _: : imperf: subj{np(str)}
przytępiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przytępić się: _: : perf: subj{np(str)} + {np(dat)}
przytępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
przytłumić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
przytłumić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,loc)}
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)}
przytomnieć: _: : imperf: subj{np(str)}
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)}
przytroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przytroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przytrzasnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przytrzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przytrzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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}
przytupywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytupywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
przytupywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
przytupywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
przytupywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przytupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
przytyć się: _: : perf: {np(dat)} + {prepnp(na,loc)}
przytyć się: _: : perf: {np(dat)} + {prepnp(w,loc)}
przytyć: _: : perf: subj{np(str)} + {comprepnp(z powodu)} + {advp(misc)}
przytyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,loc)}
przytyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(po,loc)}
przytyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
przytyć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
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)}
przyuważyć: _: : perf: subj{np(str)} + {cp(int)}
przyuważyć: _: : perf: subj{np(str)} + {cp(jak)}
przyuważyć: _: : perf: subj{np(str)} + {cp(że)}
przyuważyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(jak)}
przyuważyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
przyuważyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
przywabiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {xp(adl)}
przywabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {xp(adl)}
przywabić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {xp(adl)}
przywabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {xp(adl)}
przywalać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
przywalać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przywalać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przywalać: _: : imperf: subj{np(str)} + obj{np(part)}
przywalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przywalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przywalić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przywalić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przywalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przywalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przywalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przywalić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(pod,acc,sg,'poprzeczka',atr)}
przywalić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(w,acc,sg,'poprzeczka',atr)}
przywędrować: _: : perf: subj{np(str)} + {xp(adl)} + {xp(adl)} + {xp(perl)}
przywiać: _: : perf: {np(str)} + {prepnp(z,inst)}
przywiać: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
przywiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przywiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
przywidywać się: _: : imperf: subj{cp(że)} + {np(dat)}
przywidywać się: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)}
przywidzieć się: _: : perf: subj{cp(że)} + {np(dat)}
przywidzieć się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)}
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)}
przywlec się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
przywlec się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przywlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
przywlec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {preplexnp(z,inst,_,'siebie',natr)}
przywlec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
przywykać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
przywykać: _: : imperf: subj{np(str)} + {cp(że)}
przywykać: _: : imperf: subj{np(str)} + {cp(żeby)}
przywykać: _: : imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
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}
przyzwać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
przyzwać: _: : perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
przyzwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyzwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przyzwalać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
przyzwalać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
przyzwalać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przyzwolić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
przyzwolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
przyzwolić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
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)}
przyzywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
przyzywać: _: : imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
przyzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyzywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
psikać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
psikać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
psikać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)} + {refl}
psikać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
psioczyć: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
psioczyć: _: : imperf: subj{np(str)} + {cp(int)}
psioczyć: _: : imperf: subj{np(str)} + {cp(że)}
psioczyć: _: : imperf: subj{np(str)} + {or}
psioczyć: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
psocić się: _: : imperf: subj{np(str)} + {np(dat)}
psocić: _: : imperf: subj{np(str)}
pstrykać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(mod)}
pstrykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pstrykać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pstryknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pstryknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
pstryknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
pstryknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pstryknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pstryknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pstryknąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pstryknąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
pstryknąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pstryknąć: _: : perf: subj{np(str)} + {xp(adl)}
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)}
pucować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
pucować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pucować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pucować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
pudłować: _: : imperf: subj{np(str)} + {np(inst)}
pudłować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
pudrować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
pudrować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
pudrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pudrować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pudrować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
puentować: _: : imperf: subj{np(str)} + {cp(że)}
puentować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
puentować: _: : imperf: subj{np(str)} + {or}
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)}
puknąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
puknąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
puknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
puknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
puknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
puknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
puknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
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)}
purpurowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
purpurowieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
purpurowieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(na,loc,sg,'twarz',natr)}
purpurowieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(na,loc,sg,'twarz',natr)}
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)}
puszyć się: _: : imperf: subj{np(str)} + {cp(że)} + {xp(mod)}
puszyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(mod)}
puścić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
puścić się: _: : perf: subj{np(str)} + {np(gen)}
puścić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
puścić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
puścić się: _: : perf: subj{np(str)} + {xp(adl)}
puścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
puścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
puścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
puścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
puścić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
puścić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pykać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
pykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pyknąć: _: : perf: {np(dat)} + {xp(locat)}
pyknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pyknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
pyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pylić się: _: : imperf: subj{np(str)} + {xp(locat)}
pylić: _: : imperf: subj{np(str)} + {xp(abl)}
pylić: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(temp)}
pylić: _: : imperf: subj{np(str)} + {xp(locat)}
pyskować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pyskować: _: : imperf: subj{np(str)} + {or}
pyskować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pyskować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pyskować: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
pyskować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
pyskować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {cp(że)}
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)}
pytlować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
pytlować: _: : imperf: subj{np(str)} + {cp(int)}
pytlować: _: : imperf: subj{np(str)} + {cp(jak)}
pytlować: _: : imperf: subj{np(str)} + {cp(że)}
pytlować: _: : imperf: subj{np(str)} + {cp(żeby)}
pytlować: _: : imperf: subj{np(str)} + {or}
pytlować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pytlować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
racjonalizować się: _: : imperf: subj{np(str)}
racjonalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
racjonować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
raczkować: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
raczkować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
raczkować: _: : imperf: subj{np(str)} + {xp(locat)}
raczkować: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
radykalizować się: _: : imperf: subj{np(str)}
radykalizować: _: : imperf: subj{np(str)} + obj{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}
rapować: _: : imperf: subj{np(str)} + {cp(że)}
rapować: _: : imperf: subj{np(str)} + obj{np(str)}
rapować: _: : imperf: subj{np(str)} + {or}
rapować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rapować: _: : imperf: subj{np(str)} + {xp(locat)}
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ąbać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rąbać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rąbać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rąbać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rąbać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
rąbać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rąbać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rąbać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rąbać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
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)}
rdzewieć: _: : imperf: subj{np(str)} + {np(dat)}
rdzewieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
rdzewieć: _: : imperf: subj{np(str)} + {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)}
reasekurować się: _: : _: subj{np(str)} + {xp(locat)}
reasekurować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
reasekurować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
reasekurować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
reasumować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
reasumować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
recenzować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
recenzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
recenzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
recenzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
recenzować: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
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)}
reflektować się: _: : imperf: subj{np(str)} + {cp(że)}
reflektować się: _: : imperf: subj{np(str)} + {or}
reflektować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
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)}
reglamentować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
reglamentować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
reinterpretować: _: : imperf: subj{np(str)} + {cp(int)}
reinterpretować: _: : imperf: subj{np(str)} + {cp(że)}
reinterpretować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
reinwestować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
reinwestować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
rejterować się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
rejterować się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rejterować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
rejterować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
rekultywować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
relatywizować się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,int)}
relatywizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,int)}
relegować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {xp(abl)} + {xp(adl)}
remisować: _: : imperf: subj{np(str)} + obj{np(str)}
remisować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
remontować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
remontować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
renegocjować: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(z,inst)}
renegocjować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {prepnp(z,inst)}
reorganizować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
reorganizować się: _: : imperf: subj{np(str)} + {xp(locat)}
reorganizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
repatriować się: _: : _: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(temp)}
repatriować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(temp)}
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)}
reprodukować się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
reprodukować się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
reprodukować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
reprodukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
reprodukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
reprodukować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
reprodukować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
resocjalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
resocjalizować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
resocjalizować: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {refl}
resocjalizować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)} + {refl}
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}
restytuować się: _: : _: subj{np(str)} + {xp(locat)} + {xp(locat)}
restytuować: _: : _: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(temp)}
restytuować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)} + {xp(temp)}
retransmitować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
retransmitować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
retransmitować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
retransmitować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
retuszować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
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)}
rewindykować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)}
rewindykować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rewindykować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)}
rewolucjonizować się: _: : imperf: subj{np(str)}
rewolucjonizować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
rezydować: _: : imperf: subj{np(str)} + {prepnp(jako,str)} + {xp(locat)}
rezydować: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(mod)}
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)}
rokować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
rokować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
rokować: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(na,acc)} + {advp(misc)}
rokować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
rokować: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
rokować: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
rokować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
rokować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
rokować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
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)}
rolować się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
rolować się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
rolować się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rolować się: _: : imperf: subj{np(str)} + {xp(locat)}
rolować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rolować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
romansować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ronić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
ropieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rosić się: _: : imperf: subj{np(str)} + {np(inst)}
rosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
rozanielić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
rozanielić się: _: : perf: subj{np(str)} + {cp(int)}
rozanielić się: _: : perf: subj{np(str)} + {cp(że)}
rozanielić się: _: : perf: subj{np(str)} + {or}
rozanielić: _: : perf: subj{cp(gdy)} + {np(str)}
rozanielić: _: : perf: subj{cp(int)} + {np(str)}
rozanielić: _: : perf: subj{cp(jak)} + {np(str)}
rozanielić: _: : perf: subj{cp(jeśli)} + {np(str)}
rozanielić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozanielić: _: : perf: subj{cp(że)} + {np(str)}
rozanielić: _: : 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)}
rozanielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozbawiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozbawiać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozbawiać: _: : imperf: subj{cp(int)} + {np(str)}
rozbawiać: _: : imperf: subj{cp(jak)} + {np(str)}
rozbawiać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozbawiać: _: : imperf: subj{cp(że)} + {np(str)}
rozbawiać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozbawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
rozbebeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozbebeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
rozbryzgiwać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(na,acc)}
rozbryzgiwać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozbryzgiwać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
rozbryzgiwać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozbryzgiwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(na,acc)}
rozbryzgiwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozbryzgiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozbryzgiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbryzgiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozbrzmieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozbrzmiewać: _: : imperf: subj{np(str)} + {np(inst)}
rozbrzmiewać: _: : imperf: subj{np(str)} + {xp(locat)}
rozbuchać się: _: : perf: subj{np(str)}
rozbuchać: _: : perf: subj{np(str)} + obj{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)}
rozbujać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
rozbujać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozbujać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rozbujać: _: : perf: {np(inst)}
rozbujać: _: : perf: subj{np(str)} + obj{np(inst)} + {xp(abl)} + {xp(adl)}
rozbujać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbujać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozbujać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozbujać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
rozbujać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
rozbujać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
rozbujać: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {refl}
rozcapierzyć się: _: : perf: subj{np(str)} + {np(dat)}
rozcapierzyć: _: : perf: subj{np(str)} + obj{np(str)}
rozchichotać się: _: : perf: subj{np(str)}
rozchlapywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
rozchlapywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozchlapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rozchlapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
rozchlapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
rozchwiać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
rozchwiać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozchwytywać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
rozczapierzyć się: _: : perf: subj{np(str)} + {np(dat)}
rozczapierzyć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
rozczesać się: _: : perf: subj{np(str)} + {advp(misc)}
rozczesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozczesywać się: _: : imperf: subj{np(str)} + {advp(misc)}
rozczesywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozczłonkować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozczłonkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozczulać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
rozczulać się: _: : imperf: subj{np(str)} + {cp(int)}
rozczulać się: _: : imperf: subj{np(str)} + {cp(że)}
rozczulać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozczulać się: _: : imperf: subj{np(str)} + {or}
rozczulać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozczulać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozczulać: _: : imperf: subj{cp(int)} + {np(str)}
rozczulać: _: : imperf: subj{cp(jak)} + {np(str)}
rozczulać: _: : imperf: subj{cp(jeśli)} + {np(str)}
rozczulać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozczulać: _: : imperf: subj{cp(że)} + {np(str)}
rozczulać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozczulać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozczulić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
rozczulić się: _: : perf: subj{np(str)} + {cp(int)}
rozczulić się: _: : perf: subj{np(str)} + {cp(że)}
rozczulić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozczulić się: _: : perf: subj{np(str)} + {or}
rozczulić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozczulić: _: : perf: subj{cp(gdy)} + {np(str)}
rozczulić: _: : perf: subj{cp(int)} + {np(str)}
rozczulić: _: : perf: subj{cp(jak)} + {np(str)}
rozczulić: _: : perf: subj{cp(jeśli)} + {np(str)}
rozczulić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozczulić: _: : perf: subj{cp(że)} + {np(str)}
rozczulić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozczulić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozczytać się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
rozczytać się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)}
rozczytywać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
rozczytywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)}
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)}
rozdrażniać się: _: : imperf: subj{np(str)} + {cp(int)}
rozdrażniać się: _: : imperf: subj{np(str)} + {cp(że)}
rozdrażniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozdrażniać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozdrażniać: _: : imperf: subj{cp(int)} + {np(str)}
rozdrażniać: _: : imperf: subj{cp(jak)} + {np(str)}
rozdrażniać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozdrażniać: _: : imperf: subj{cp(że)} + {np(str)}
rozdrażniać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozdrażniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozdrażnić się: _: : perf: subj{np(str)} + {cp(int)}
rozdrażnić się: _: : perf: subj{np(str)} + {cp(że)}
rozdrażnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozdrażnić: _: : perf: subj{cp(gdy)} + {np(str)}
rozdrażnić: _: : perf: subj{cp(int)} + {np(str)}
rozdrażnić: _: : perf: subj{cp(jak)} + {np(str)}
rozdrażnić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozdrażnić: _: : perf: subj{cp(że)} + {np(str)}
rozdrażnić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozdrażnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
rozdwajać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozdwajać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozdwoić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozdwoić: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
rozdziawiać się: _: : imperf: subj{np(str)}
rozdziawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozdziawić się: _: : perf: subj{np(str)}
rozdziawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
rozdzwonić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozdzwonić się: _: : perf: subj{np(str)} + {np(inst)}
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}
rozedrgać się: _: : perf: subj{np(str)} + {advp(misc)}
rozedrgać się: _: : perf: subj{np(str)} + {np(inst)}
rozedrgać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozedrgać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozedrgać się: _: : perf: subj{np(str)} + {xp(locat)} + {xp(perl)}
rozedrgać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozedrgać: _: : perf: subj{np(str)} + {xp(locat)}
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)}
rozentuzjazmować się: _: : perf: subj{np(str)} + {cp(int)}
rozentuzjazmować się: _: : perf: subj{np(str)} + {cp(że)}
rozentuzjazmować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozentuzjazmować się: _: : perf: subj{np(str)} + {or}
rozentuzjazmować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
rozentuzjazmować: _: : perf: subj{cp(int)} + {np(str)}
rozentuzjazmować: _: : perf: subj{cp(że)} + {np(str)}
rozentuzjazmować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
rozentuzjazmować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozentuzjazmować: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
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)}
rozeschnąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozeschnąć się: _: : perf: subj{np(str)} + {xp(locat)}
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)}
rozeźlić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
rozeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rozeźlić: _: : perf: subj{cp(gdy)} + {np(str)}
rozeźlić: _: : perf: subj{cp(jak)} + {np(str)}
rozeźlić: _: : perf: subj{cp(jeśli)} + {np(str)}
rozeźlić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozeźlić: _: : perf: subj{cp(że)} + {np(str)}
rozeźlić: _: : 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)}
rozeźlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozformować się: _: : perf: subj{np(str)} + {xp(locat)}
rozformować: _: : perf: subj{np(str)} + obj{np(str)}
rozgadać się: _: : perf: subj{np(str)} + {comprepnp(na temat)}
rozgadać się: _: : perf: subj{np(str)} + {cp(int)}
rozgadać się: _: : perf: subj{np(str)} + {cp(jak)}
rozgadać się: _: : perf: subj{np(str)} + {cp(że)}
rozgadać się: _: : perf: subj{np(str)} + {or}
rozgadać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozgadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
rozgadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
rozgadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
rozgadać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rozgadać: _: : perf: subj{np(str)} + {np(dat)} + {or}
rozgadać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozgadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozgadywać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
rozgadywać się: _: : imperf: subj{np(str)} + {cp(int)}
rozgadywać się: _: : imperf: subj{np(str)} + {cp(jak)}
rozgadywać się: _: : imperf: subj{np(str)} + {cp(że)}
rozgadywać się: _: : imperf: subj{np(str)} + {or}
rozgadywać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozgadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
rozgadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
rozgadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
rozgadywać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rozgadywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
rozgadywać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
rozgadywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozgałęziać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
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)}
rozglądnąć się: _: : perf: subj{np(str)} + {cp(int)} + {xp(adl)}
rozglądnąć się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozglądnąć się: _: : perf: subj{np(str)} + {prepnp(po,loc); xp(locat)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
rozglądnąć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozgłaszać: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
rozgłaszać: _: : imperf: subj{np(str)} + {cp(że)} + {xp(locat)}
rozgłaszać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
rozgłaszać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
rozgłaszać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
rozgłaszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
rozgłaszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(wśród,gen)}
rozgłaszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
rozgłaszać: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(int)}
rozgłaszać: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(że)}
rozgłaszać: _: : imperf: subj{np(str)} + {prepnp(wśród,gen)} + {or}
rozgłaszać: _: : imperf: subj{np(str)} + {xp(locat)} + {or}
rozgłosić: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
rozgłosić: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
rozgłosić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
rozgłosić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
rozgłosić: _: : perf: subj{np(str)} + {np(dat)} + {or}
rozgłosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
rozgłosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(wśród,gen)}
rozgłosić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
rozgłosić: _: : perf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(int)}
rozgłosić: _: : perf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(że)}
rozgłosić: _: : perf: subj{np(str)} + {prepnp(wśród,gen)} + {or}
rozgłosić: _: : perf: subj{np(str)} + {xp(locat)} + {or}
rozgniatać się: _: : imperf: subj{np(str)} + {np(dat)}
rozgniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozgniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rozgniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
rozgnieść się: _: : perf: subj{np(str)} + {np(dat)}
rozgnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozgnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rozgnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
rozgoryczać się: _: : imperf: subj{np(str)} + {np(inst)} + {advp(misc)}
rozgoryczać się: _: : imperf: subj{np(str)} + {or}
rozgoryczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
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)}
rozgościć się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
rozgościć się: _: : perf: subj{np(str)} + {xp(locat)}
rozgotować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozgotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozgrabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozgrabić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozgramiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozgraniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozgraniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rozgraniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
rozgraniczać: _: : imperf: subj{np(str)} + {prepnp(między,inst)}
rozgraniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozgraniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rozgraniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
rozgraniczyć: _: : perf: subj{np(str)} + {prepnp(między,inst)}
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)}
rozgryzać: _: : imperf: subj{np(str)} + {cp(int)}
rozgryzać: _: : imperf: subj{np(str)} + {cp(że)}
rozgryzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozgryźć: _: : perf: subj{np(str)} + {cp(int)}
rozgryźć: _: : perf: subj{np(str)} + {cp(że)}
rozgryźć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
rozgrzeszać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
rozgrzeszać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
rozgrzeszać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,że)} + {refl}
rozgrzeszać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
rozgrzeszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
rozgrzeszać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
rozgrzeszać: _: : imperf: subj{np(str)} + {or} + {refl}
rozgrzeszyć: _: : perf: subj{np(str)} + {cp(że)} + {refl}
rozgrzeszyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
rozgrzeszyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,że)} + {refl}
rozgrzeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
rozgrzeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
rozgrzeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
rozgrzeszyć: _: : perf: subj{np(str)} + {or} + {refl}
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)}
rozhulać się: _: : perf: subj{np(str)} + {xp(locat)}
rozhulać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozhuśtać się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
rozhuśtać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozhuśtać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
roziskrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
roziskrzyć: _: : perf: {np(dat)} + {np(inst)} + {np(str)}
roziskrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozjarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozjarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozjarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozjarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
rozjarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozjarzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozjarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
rozjątrzać się: _: : imperf: subj{np(str)} + {or}
rozjątrzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozjątrzać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozjątrzać: _: : imperf: subj{cp(int)} + {np(str)}
rozjątrzać: _: : imperf: subj{cp(jak)} + {np(str)}
rozjątrzać: _: : imperf: subj{cp(jeśli)} + {np(str)}
rozjątrzać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozjątrzać: _: : imperf: subj{cp(że)} + {np(str)}
rozjątrzać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozjątrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozjątrzyć się: _: : perf: subj{np(str)} + {or}
rozjątrzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozjątrzyć: _: : perf: subj{cp(gdy)} + {np(str)}
rozjątrzyć: _: : perf: subj{cp(int)} + {np(str)}
rozjątrzyć: _: : perf: subj{cp(jak)} + {np(str)}
rozjątrzyć: _: : perf: subj{cp(jeśli)} + {np(str)}
rozjątrzyć: _: : perf: subj{cp(kiedy)} + {np(str)}
rozjątrzyć: _: : perf: subj{cp(że)} + {np(str)}
rozjątrzyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozjątrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozjebać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozjebać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
rozjebać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rozjebać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozjebać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozjebać się: _: : perf: subj{np(str)} + {xp(locat)}
rozjebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozjebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozjebać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
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)}
rozjuszać się: _: : imperf: subj{np(str)} + {cp(że)}
rozjuszać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozjuszać się: _: : imperf: subj{np(str)} + {or}
rozjuszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozjuszać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozjuszać: _: : imperf: subj{cp(int)} + {np(str)}
rozjuszać: _: : imperf: subj{cp(jak)} + {np(str)}
rozjuszać: _: : imperf: subj{cp(jeśli)} + {np(str)}
rozjuszać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozjuszać: _: : imperf: subj{cp(że)} + {np(str)}
rozjuszać: _: : 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)}
rozjuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozjuszyć się: _: : perf: subj{np(str)} + {cp(że)}
rozjuszyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozjuszyć się: _: : perf: subj{np(str)} + {or}
rozjuszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozjuszyć: _: : perf: subj{cp(gdy)} + {np(str)}
rozjuszyć: _: : perf: subj{cp(int)} + {np(str)}
rozjuszyć: _: : perf: subj{cp(jak)} + {np(str)}
rozjuszyć: _: : perf: subj{cp(jeśli)} + {np(str)}
rozjuszyć: _: : perf: subj{cp(kiedy)} + {np(str)}
rozjuszyć: _: : perf: subj{cp(że)} + {np(str)}
rozjuszyć: _: : 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)}
rozjuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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}
rozkleić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
rozkleić się: _: : perf: subj{np(str)} + {cp(int)}
rozkleić się: _: : perf: subj{np(str)} + {cp(że)}
rozkleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozkleić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozkleić się: _: : perf: subj{np(str)} + {or}
rozkleić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozkleić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozkleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozklejać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
rozklejać się: _: : imperf: subj{np(str)} + {cp(int)}
rozklejać się: _: : imperf: subj{np(str)} + {cp(że)}
rozklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozklejać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozklejać się: _: : imperf: subj{np(str)} + {or}
rozklejać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozklejać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozklekotać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
rozklekotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozkładać się: _: : imperf: subj{np(str)} + {prepnp(między,acc)}
rozkładać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozkładać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozkładać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozkochać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozkochać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,loc)}
rozkojarzyć się: _: : perf: subj{np(str)} + {cp(int)}
rozkojarzyć się: _: : perf: subj{np(str)} + {cp(że)}
rozkojarzyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozkojarzyć: _: : perf: subj{cp(gdy)} + {np(str)}
rozkojarzyć: _: : perf: subj{cp(int)} + {np(str)}
rozkojarzyć: _: : perf: subj{cp(jak)} + {np(str)}
rozkojarzyć: _: : perf: subj{cp(kiedy)} + {np(str)}
rozkojarzyć: _: : perf: subj{cp(że)} + {np(str)}
rozkojarzyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozkojarzyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozkolportować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(locat)}
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)}
rozkraczyć się: _: : perf: subj{np(str)} + {xp(locat)}
rozkraczyć: _: : perf: {np(str)}
rozkraczyć: _: : perf: subj{np(str)} + obj{lexnp(str,pl,'noga',atr)} + {xp(locat)}
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)}
rozkroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
rozkroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozkruszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozkruszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozkruszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozkruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)} + {xp(locat)}
rozkruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {xp(locat)}
rozkrzewiać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rozkrzewiać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozkrzewiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozkrzewiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozkrzewić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rozkrzewić się: _: : perf: subj{np(str)} + {xp(locat)}
rozkrzewić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozkrzyżować: _: : perf: subj{np(str)} + obj{np(str)}
rozkuć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
rozkuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
rozkwasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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źniać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozluźniać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozluźniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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łamać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozłamać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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}
rozłożyć się: _: : perf: subj{np(str)} + {prepnp(między,acc)}
rozłożyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozłożyć się: _: : perf: subj{np(str)} + {xp(locat)}
rozłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozłożyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozłupać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozłupać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozłupać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
rozłupywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozłupywać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozłupywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
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)}
rozmasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozmasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
rozmieniać się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,_,'drobne',natr)}
rozmieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
rozmienić się: _: : perf: subj{np(str)} + {preplexnp(na,acc,_,'drobne',natr)}
rozmienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
rozmienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozmierzwić się: _: : perf: subj{np(str)} + {np(dat)}
rozmieszać się: _: : perf: subj{np(str)}
rozmieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rozmieszać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'reszta',natr)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'szczęt',natr)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',ratr)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozmięknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
rozmigotać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozmigotać się: _: : perf: subj{np(str)} + {np(inst)}
rozmigotać się: _: : perf: subj{np(str)} + {xp(locat)}
rozmijać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozmiłować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozmiłować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozminąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozminować: _: : perf: subj{np(str)} + obj{np(str)}
rozminowywać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
rozmoczyć się: _: : perf: subj{np(str)} + {np(dat)}
rozmoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozmontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozmontowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
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)}
rozmydlić się: _: : perf: subj{np(str)}
rozmydlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
roznamiętnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
roznamiętnić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
roznamiętnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
roznamiętnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
roznegliżować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
roznegliżować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
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)}
rozorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
rozpanoszyć się: _: : perf: subj{np(str)} + {xp(locat)}
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)}
rozpełzać się: _: : imperf: subj{np(str)} + {xp(abl)}
rozpełzać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozpełzać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpełzać się: _: : imperf: subj{np(str)} + {xp(perl)}
rozpełznąć się: _: : perf: subj{np(str)} + {xp(abl)}
rozpełznąć się: _: : perf: subj{np(str)} + {xp(adl)}
rozpełznąć się: _: : perf: subj{np(str)} + {xp(locat)}
rozpełznąć się: _: : perf: subj{np(str)} + {xp(perl)}
rozpędzać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozpędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpędzić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozpędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpętać się: _: : perf: subj{np(str)} + {np(dat)}
rozpętać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpętać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
rozpętywać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
rozpętywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
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)}
rozpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
rozpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpieprzyć się: _: : perf: subj{np(str)} + {np(inst)}
rozpieprzyć się: _: : perf: subj{np(str)} + {xp(locat)}
rozpieprzyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(str)}
rozpieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozpieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozpieprzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpierać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpierzchać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
rozpierzchać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
rozpierzchać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(perl)}
rozpierzchać: _: : imperf: subj{np(str)} + {np(str)} + {xp(perl)}
rozpierzchnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
rozpierzchnąć się: _: : perf: subj{np(str)} + {xp(adl)}
rozpierzchnąć się: _: : perf: subj{np(str)} + {xp(locat)}
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)}
rozplakatować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
rozplatać się: _: : imperf: subj{np(str)} + {np(dat)}
rozplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
rozplenić się: _: : perf: subj{np(str)} + {xp(adl)}
rozplenić się: _: : perf: subj{np(str)} + {xp(locat)}
rozplenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozplenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpleść się: _: : perf: subj{np(str)} + {np(dat)}
rozpleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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łaszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozpłaszczać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
rozpłaszczać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
rozpłaszczać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozpłaszczać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rozpłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
rozpłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozpłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
rozpłaszczyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozpłaszczyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
rozpłaszczyć się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
rozpłaszczyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozpłaszczyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozpłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
rozpłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozpłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
rozpłatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
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)}
rozpogadzać się: _: : imperf: subj{np(str)} + {np(dat)}
rozpogadzać się: _: : imperf: {xp(locat)}
rozpogadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpogadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpogodzić się: _: : perf: subj{np(str)} + {np(dat)}
rozpogodzić się: _: : perf: {xp(locat)}
rozpogodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpogodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
rozpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
rozpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
rozpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
rozpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
rozpowiadać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozpowiadać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
rozpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(jak)}
rozpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
rozpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {or}
rozpowiedzieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozpowiedzieć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
rozprężać się: _: : imperf: subj{np(str)}
rozprężać: _: : imperf: subj{np(str)} + obj{np(str)}
rozprężyć się: _: : perf: subj{np(str)}
rozprężyć: _: : perf: subj{np(str)} + obj{np(str)}
rozpromieniać się: _: : imperf: subj{np(str)} + {cp(że)}
rozpromieniać się: _: : imperf: subj{np(str)} + {or}
rozpromieniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozpromieniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpromienić się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'myśl',atr)}
rozpromienić się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'widok',atr)}
rozpromienić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
rozpromienić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozpromienić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rozpromienić się: _: : perf: subj{np(str)} + {xp(locat)}
rozpromienić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpropagować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozprostować się: _: : perf: subj{np(str)}
rozprostować: _: : perf: subj{np(str)} + obj{np(str)} + {np(str)}
rozprostowywać się: _: : imperf: subj{np(str)} + {np(dat)}
rozprostowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
rozpylać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozpylać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozpylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
rozpylać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
rozpylić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
rozpylić się: _: : perf: subj{np(str)} + {xp(locat)}
rozpylić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpylić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
rozpylić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozpylić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
rozrabiać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rozrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
rozrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rozrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozradować się: _: : perf: subj{np(str)} + {cp(int)}
rozradować się: _: : perf: subj{np(str)} + {cp(że)}
rozradować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozradować się: _: : perf: subj{np(str)} + {or}
rozradować się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rozradować się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozradować się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
rozradować: _: : perf: subj{cp(gdy)} + {np(str)}
rozradować: _: : perf: subj{cp(int)} + {np(str)}
rozradować: _: : perf: subj{cp(jak)} + {np(str)}
rozradować: _: : perf: subj{cp(kiedy)} + {np(str)}
rozradować: _: : perf: subj{cp(że)} + {np(str)}
rozradować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozradować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(str,int)} + {np(str)}
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)}
rozrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozregulować się: _: : perf: subj{np(str)} + {np(dat)}
rozregulować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozreklamować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
rozreklamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozreklamować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozreklamować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
rozrobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
rozrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
rozrysować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
rozrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
rozrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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)}
rozrzedzać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
rozrzedzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozrzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozrzedzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozrzedzić się: _: : perf: subj{np(str)}
rozrzedzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozrzewniać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
rozrzewniać się: _: : imperf: subj{np(str)} + {cp(int)}
rozrzewniać się: _: : imperf: subj{np(str)} + {cp(że)}
rozrzewniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozrzewniać się: _: : imperf: subj{np(str)} + {or}
rozrzewniać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozrzewniać: _: : imperf: subj{cp(gdy)} + {np(str)}
rozrzewniać: _: : imperf: subj{cp(int)} + {np(str)}
rozrzewniać: _: : imperf: subj{cp(jak)} + {np(str)}
rozrzewniać: _: : imperf: subj{cp(jeśli)} + {np(str)}
rozrzewniać: _: : imperf: subj{cp(kiedy)} + {np(str)}
rozrzewniać: _: : imperf: subj{cp(że)} + {np(str)}
rozrzewniać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozrzewniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozrzewnić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
rozrzewnić się: _: : perf: subj{np(str)} + {cp(int)}
rozrzewnić się: _: : perf: subj{np(str)} + {cp(że)}
rozrzewnić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozrzewnić się: _: : perf: subj{np(str)} + {or}
rozrzewnić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozrzewnić: _: : perf: subj{cp(gdy)} + {np(str)}
rozrzewnić: _: : perf: subj{cp(int)} + {np(str)}
rozrzewnić: _: : perf: subj{cp(jak)} + {np(str)}
rozrzewnić: _: : perf: subj{cp(jeśli)} + {np(str)}
rozrzewnić: _: : perf: subj{cp(kiedy)} + {np(str)}
rozrzewnić: _: : perf: subj{cp(że)} + {np(str)}
rozrzewnić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozrzewnić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
rozrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
rozrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
rozrzucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
rozrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
rozrzucić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozsadzać: _: : imperf: {np(dat)} + {np(str)} + {prepnp(od,gen)}
rozsadzać: _: : imperf: {np(dat)} + {np(str)} + {prepnp(z,gen)}
rozsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozsadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rozsadzić: _: : perf: {np(dat)} + {np(str)} + {prepnp(od,gen)}
rozsadzić: _: : perf: {np(dat)} + {np(str)} + {prepnp(z,gen)}
rozsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozsadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
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)}
rozsiać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
rozsiać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozsiadać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozsiąść się: _: : perf: subj{np(str)} + {xp(locat)}
rozsierdzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozsierdzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
rozsierdzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozsierdzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozsierdzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozsierdzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rozsierdzić: _: : perf: subj{cp(gdy)} + {np(str)}
rozsierdzić: _: : perf: subj{cp(jak)} + {np(str)}
rozsierdzić: _: : perf: subj{cp(jeśli)} + {np(str)}
rozsierdzić: _: : perf: subj{cp(że)} + {np(str)}
rozsierdzić: _: : 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)}
rozsierdzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozsiewać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(locat)}
rozsiewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rozsiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozsiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozsławiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(locat)}
rozsławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(locat)}
rozsławić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(locat)}
rozsławić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {xp(locat)}
rozsmakować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozsmakowywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rozsmarować się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozsmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozsmarowywać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
rozsmarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozsnuwać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozsnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
rozsnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
rozstrzelić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozstrzelić się: _: : perf: subj{np(str)} + {xp(adl)}
rozstrzelić się: _: : perf: subj{np(str)} + {xp(locat)}
rozstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
rozsunąć się: _: : perf: subj{np(str)} + {np(dat)}
rozsunąć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
rozsunąć się: _: : perf: subj{np(str)} + {xp(adl)}
rozsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
rozsunąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozsupłać się: _: : perf: subj{np(str)} + {np(dat)}
rozsupłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozsupływać się: _: : imperf: subj{np(str)} + {np(dat)}
rozsupływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozsupływać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozsuwać się: _: : imperf: subj{np(str)} + {np(dat)}
rozsuwać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
rozsuwać się: _: : imperf: subj{np(str)} + {xp(adl)}
rozsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
rozsuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozsychać się: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
rozsychać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',atr)}
rozsychać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
rozsychać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
rozsychać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
rozsychać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
rozsychać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
rozsychać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozsychać: _: : imperf: subj{np(str)}
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)}
rozszaleć się: _: : perf: subj{np(str)} + {np(inst)}
rozszaleć się: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
rozszaleć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozszaleć się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
rozszaleć się: _: : perf: subj{np(str)} + {xp(locat)}
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)}
rozszczekać się: _: : perf: subj{np(str)} + {xp(mod)}
rozszczekać się: _: : perf: subj{np(str)} + {xp(temp)}
rozszczepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozszczepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozszczepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozszczepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozszczepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
rozszczepić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozszczepić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
rozszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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śpiewać się: _: : perf: subj{np(str)} + {np(inst)} + {or}
rozśpiewać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
rozśpiewać: _: : perf: subj{np(str)} + {np(str)}
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)}
roztańczyć się: _: : perf: subj{np(str)}
roztańczyć: _: : perf: subj{np(str)} + obj{np(str)}
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ąbić się: _: : perf: subj{np(str)}
roztrąbić: _: : perf: subj{np(str)} + {cp(int)} + {xp(adl)}
roztrąbić: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
roztrąbić: _: : perf: subj{np(str)} + {cp(że)} + {xp(adl)}
roztrąbić: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
roztrąbić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
roztrąbić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
roztrąbić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
roztrąbić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
roztrąbić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(po,loc)}
roztrąbić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(adl)}
roztrąbić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(locat)}
roztrąbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(po,loc)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(wśród,gen)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(adl)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(int)}
roztrąbić: _: : perf: subj{np(str)} + {prepnp(wśród,gen)} + {cp(że)}
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)}
roztrwaniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
roztrwaniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
roztrwonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
roztrzaskać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
roztrzaskać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
roztrzaskać się: _: : perf: subj{np(str)} + {np(inst)}
roztrzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
roztrzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
roztrzaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
roztrzaskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
roztrzaskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
roztrzaskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
roztrzaskiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {xp(locat)}
roztrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
roztrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
roztrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
roztrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
roztrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
roztrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {xp(locat)}
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}
roztyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
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}
rozwalać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {xp(temp)}
rozwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozwalić się: _: : perf: subj{np(str)} + {xp(locat)}
rozwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {xp(temp)}
rozwalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozwałkować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(inst)}
rozwarstwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozwarstwić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
rozwiązać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
rozwiązać się: _: : perf: subj{np(str)} + {np(str)}
rozwiązać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwiązać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozwiązywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
rozwiązywać się: _: : imperf: subj{np(str)} + {np(inst)}
rozwiązywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozwiązywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwibrować się: _: : perf: subj{np(str)} + {np(inst)}
rozwibrować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
rozwibrować: _: : perf: subj{np(str)}
rozwichrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozwichrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwidlać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
rozwidlać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
rozwidlać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozwidlać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(locat)}
rozwidlać się: _: : imperf: subj{np(str)} + {xp(mod)}
rozwidlać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozwidniać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)} + {xp(locat)}
rozwidniać się: _: : imperf: subj{np(str)} + {np(inst)}
rozwidniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozwidnić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)} + {xp(locat)}
rozwidnić się: _: : perf: subj{np(str)} + {np(inst)}
rozwidnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
rozwłóczyć się: _: : perf: subj{np(str)} + {xp(locat)}
rozwłóczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozwodnić się: _: : perf: subj{np(str)}
rozwodnić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
rozwrzeszczeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozwrzeszczeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
rozwrzeszczeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozwścieczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozwścieczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
rozwścieczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozwścieczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozwścieczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
rozwścieczyć: _: : perf: subj{cp(gdy)} + {np(str)}
rozwścieczyć: _: : perf: subj{cp(jak)} + {np(str)}
rozwścieczyć: _: : perf: subj{cp(jeśli)} + {np(str)}
rozwścieczyć: _: : perf: subj{cp(kiedy)} + {np(str)}
rozwścieczyć: _: : perf: subj{cp(że)} + {np(str)}
rozwścieczyć: _: : 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)}
rozwścieczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
rozżarzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
rozżarzać się: _: : imperf: subj{np(str)} + {xp(locat)}
rozżarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozżarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
rozżarzyć się: _: : perf: subj{np(str)} + {np(inst)}
rozżarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
rugać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
rugać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rugać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
ryglować się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
ryglować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
ryglować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ryglować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
rypać się: _: : imperf: subj{np(str)} + {np(dat)}
rypać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
rypać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
rypać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
rypać: _: : imperf: {np(str)} + {xp(locat)}
rypać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rypać: _: : imperf: subj{np(str)} + {np(part)}
rypać: _: : imperf: subj{np(str)} + {np(str)} + {xp(locat)}
rypać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rypać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rypać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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)}
rzezać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
rzezać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
rzezać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rzezać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(mod)}
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)}
rzęzić: _: : imperf: {np(dat)} + {xp(locat)}
rzęzić: _: : imperf: subj{np(str)} + {cp(że)}
rzęzić: _: : imperf: subj{np(str)} + {cp(żeby)}
rzęzić: _: : imperf: subj{np(str)} + {np(dat)}
rzęzić: _: : imperf: subj{np(str)} + {np(inst)}
rzęzić: _: : imperf: subj{np(str)} + {or}
rzęzić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)}
rzęzić: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
rzęzić: _: : imperf: subj{np(str)} + {xp(abl)}
rzęzić: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
rzygnąć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
rzygnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rzygnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
rzygnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
rzygnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
rżeć: _: : imperf: subj{np(str)}
rżeć: _: : imperf: subj{np(str)} + {or}
rżeć: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
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)}
sabotować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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)}
sapać: _: : imperf: subj{np(str)} + {np(inst)}
sapać: _: : imperf: subj{np(str)} + {or}
sapnąć: _: : perf: subj{np(str)} + {np(inst)}
sapnąć: _: : perf: subj{np(str)} + {or}
sarkać: _: : imperf: subj{np(str)} + {or}
sarkać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
sarknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
sarknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
sarknąć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
sarknąć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
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)}
scedować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
scedować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
scedować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {comprepnp(na rzecz)}
scementować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
scementować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
scementować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
scementować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
scementować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
scementować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,acc)}
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)}
schlebiać: _: : imperf: subj{cp(że)} + {np(dat)}
schlebiać: _: : imperf: subj{ncp(str,że)} + {np(dat)}
schlebiać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
schlebiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
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}
schnąć: _: : imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
schnąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(dur)}
schnąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
schnąć: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
schnąć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
schnąć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
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)}
schrupać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(inst)}
schrupać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
schrzanić się: _: : perf: subj{np(str)} + {np(dat)}
schrzanić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
sczepić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
sczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
sczeznąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
sczytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {lexnp(inst,sg,'wzgląd',ratr)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',ratr)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'wzgląd',ratr)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
segregować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
sekować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
sekować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
sekretarzować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(dur)}
sekretarzować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
sekretarzować: _: : imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
sekretarzować: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
sekundować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
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}
separować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
separować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
seplenić: _: : imperf: subj{np(str)} + {cp(że)}
seplenić: _: : imperf: subj{np(str)} + {np(inst)} + {or}
seplenić: _: : imperf: subj{np(str)} + {np(str)}
seplenić: _: : imperf: subj{np(str)} + {prepadjp(po,postp)} + {xp(adl)}
seplenić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
seplenić: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
seplenić: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
seplenić: _: : imperf: subj{np(str)} + {xp(mod)} + {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)}
sfabrykować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sfabrykować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sfalować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
sfalować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
sfalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sfałdować się: _: : perf: subj{np(str)} + {xp(locat)}
sfałdować: _: : perf: subj{np(str)} + obj{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)}
sfeminizować się: _: : perf: subj{np(str)}
sfeminizować: _: : perf: subj{np(str)} + obj{np(str)}
sfermentować: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
sfermentować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
sfermentować: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
sfermentować: _: : perf: subj{np(str)} + {prepnp(w,acc)}
sfermentować: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
sfingować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
sflaczeć: _: : perf: subj{np(str)} + {np(dat)}
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)}
sfrunąć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
sfruwać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
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)}
siadywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {xp(locat)}
siąkać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
siąkać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
siąknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
siąknąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
siąpić: _: : imperf: subj{E} + {prepnp(z,gen)}
siąpić: _: : imperf: subj{E} + {xp(locat)}
siąpić: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
siąpić: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
siąść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
siąść: _: : perf: subj{np(str)} + {xp(adl)}
siąść: _: : perf: subj{np(str)} + {xp(locat)}
siec: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(perl)}
siec: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
siec: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(perl)}
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)}
siekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
siekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
siekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
siekać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
sięgać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
sięgać: _: : imperf: subj{np(str)} + {np(gen)}
sięgać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)} + {xp(adl)}
sięgnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
sięgnąć: _: : perf: subj{np(str)} + {np(gen)}
sięgnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)} + {xp(adl)}
sikać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
sikać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
sikać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
sikać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
sikać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
siknąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
siknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
siknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
siknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
siknąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
siknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
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)}
sinieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
sinieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sinieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
sinieć: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
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)}
skalować się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
skalować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
skalować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
skalować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
skalować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {advp(misc)}
skalpować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
skalpować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
skalpować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skamienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skamienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skamienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
skamienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
skamienieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
skandalizować: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)}
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)}
skapitalizować się: _: : perf: subj{np(str)} + {advp(misc)}
skapitalizować się: _: : perf: subj{np(str)} + {xp(locat)}
skapitalizować się: _: : perf: subj{np(str)} + {xp(temp)}
skapitalizować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
skapitalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skapitalizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skapitalizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
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)}
skarać: _: : 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)} + {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)}
skarleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skarleć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
skarleć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
skarleć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(pod,inst)}
skarleć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
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)}
skatalogować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
skatalogować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
skatalogować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
skatalogować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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ąpać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skąpać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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}
skląć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
skląć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
skląć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
skląć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
skląć: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
sklecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sklecić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'kolano',natr)}
sklecić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'poczekanie',natr)}
sklecić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
sklecić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
sklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
sklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(mod)}
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łębić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skłębić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skłębić się: _: : perf: subj{np(str)} + {xp(locat)}
skłębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
skłębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
skłębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
skłócać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
skłócać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
skłócić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
skłócić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
sknocić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
skodyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
skoligacić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skoligacić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
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)}
skołtunić się: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
skołtunić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skołtunić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
skomasować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skomasować się: _: : perf: subj{np(str)} + {xp(locat)}
skomasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
skomasować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skombinować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skombinować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
skombinować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
skomentować: _: : perf: subj{np(str)} + {cp(że)}
skomentować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {or}
skomercjalizować się: _: : perf: subj{np(str)}
skomercjalizować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
skomlić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
skomlić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
skomlić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
skomlić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
skomlić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
skomlić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
skompensować się: _: : perf: subj{np(str)} + {np(dat)}
skompensować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
skompensować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
skompensować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
skompensować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc); prepncp(przez,acc,że)}
skompensować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
skompilować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skompilować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
skompilować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
skompletować się: _: : perf: subj{np(str)}
skompletować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,inst)}
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)}
skomunalizować się: _: : perf: subj{np(str)} + {xp(temp)}
skomunalizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
skomunikować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
skomunikować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
skomunikować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
skomunikować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
skomunikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
skondensować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(w,acc)}
skondensować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skondensować się: _: : perf: subj{np(str)} + {xp(locat)}
skondensować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(w,acc)}
skondensować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
skondensować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
skondensować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skonfigurować się: _: : perf: subj{np(str)} + {xp(mod)}
skonfigurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
skonfigurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(mod)}
skonfigurować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
skonfiskować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na rzecz)}
skonfliktować się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
skonfliktować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
skonfliktować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
skonfliktować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
skonfliktować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
skonfliktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
skonfliktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
skonfliktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
skonfliktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
skonfliktować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
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}
skonfundować się: _: : perf: subj{np(str)} + {cp(że)}
skonfundować: _: : perf: subj{cp(int)} + obj{np(str)}
skonfundować: _: : perf: subj{cp(że)} + obj{np(str)}
skonfundować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
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}
skonsternować się: _: : perf: subj{np(str)} + {cp(że)}
skonsternować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
skonsternować się: _: : perf: subj{np(str)} + {or}
skonsternować: _: : perf: subj{cp(gdy)} + {np(str)}
skonsternować: _: : perf: subj{cp(int)} + {np(str)}
skonsternować: _: : perf: subj{cp(jak)} + {np(str)}
skonsternować: _: : perf: subj{cp(jeśli)} + {np(str)}
skonsternować: _: : perf: subj{cp(kiedy)} + {np(str)}
skonsternować: _: : perf: subj{cp(że)} + {np(str)}
skonsternować: _: : 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)}
skonsternować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
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)}
skontrastować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
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)}
skontrować: _: : perf: subj{np(str)} + {cp(że)}
skontrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skontrować: _: : perf: subj{np(str)} + {or}
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)}
skorodować: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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)}
skostnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skostnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skostnieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skostnieć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skostnieć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skoszarować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skosztować: _: : perf: subj{np(str)} + obj{np(part)}
skotłować się: _: : perf: subj{np(str)} + {xp(locat)}
skotłować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
skradać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(locat)} + {xp(mod)} + {xp(perl)}
skradać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(mod)}
skrapiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
skrapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
skredytować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
skredytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skredytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
skrobnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
skrobnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
skrobnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
skrobnąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
skrobnąć: _: : 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)}
skrobnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
skrobnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
skrobnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
skrobnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
skrobnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
skrobnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
skrobnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
skrobnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
skrobnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
skrobnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
skrobnąć: _: : 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)}
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)}
skropić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
skropić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
skruszeć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
skruszeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
skruszeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skruszeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
skruszeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
skruszeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skruszeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skruszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
skruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
skruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
skruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
skrwawić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skrwawić się: _: : perf: subj{np(str)} + {xp(locat)}
skrwawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
skrystalizować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skrystalizować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
skrystalizować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
skrystalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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}
skrzepnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
skrzepnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skrzepnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skrzepnąć: _: : perf: subj{np(str)} + {preplexnp(w,loc,sg,'siebie',natr)}
skrzesać się: _: : perf: subj{np(str)} + {xp(locat)}
skrzesać: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
skrzesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skrzesać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
skrzesać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
skrzesać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skrzesać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
skrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
skrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {or}
skrzyczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
skrzykiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
skrzykiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
skrzykiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
skrzykiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
skrzykiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
skrzykiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
skrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
skrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
skrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
skrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
skrzykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
skrzyknąć się: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
skrzyknąć się: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
skrzyknąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
skrzyknąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
skrzyknąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
skrzyknąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
skrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
skrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
skrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
skrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
skrzyknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {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)}
skumać się: _: : perf: subj{np(str)} + {cp(int)}
skumać się: _: : perf: subj{np(str)} + {cp(że)}
skumać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
skumać: _: : perf: subj{np(str)} + {cp(int)}
skumać: _: : perf: subj{np(str)} + {cp(że)}
skumać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
skumulować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skumulować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
skumulować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skumulować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
skumulować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
skumulować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skundlić się: _: : perf: subj{np(str)} + {advp(misc)}
skundlić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
skundlić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
skwasić się: _: : perf: subj{np(str)} + {np(dat)}
skwasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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łaniać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
słaniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
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}
smagać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
smagać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
smagnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
smagnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)} + {refl}
smagnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
smagnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
smagnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
smagnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
smagnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
smakować: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
smakować: _: : imperf: subj{np(str)} + {np(dat)}
smakować: _: : imperf: subj{np(str)} + obj{np(str)}
smalić się: _: : imperf: subj{np(str)} + {xp(locat)}
smalić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
smalić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,pl,'cholewka',natr)}
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)}
smolić się: _: : imperf: subj{np(str)} + {xp(locat)}
smolić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
smolić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
smolić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
smolić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,pl,'cholewka',natr)}
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)}
smutnieć: _: : imperf: subj{np(str)} + {cp(że)}
smutnieć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
smutnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
smutnieć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
smutnieć: _: : imperf: subj{np(str)} + {or}
smutnieć: _: : imperf: subj{np(str)} + {xp(locat)}
snobować się: _: : imperf: subj{np(str)} + {np(inst)}
snobować się: _: : imperf: subj{np(str)} + {prepnp(na,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)}
socjalizować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
socjalizować: _: : imperf: subj{np(str)}
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)}
sondować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(int)}
sondować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)} + {prepnp(u,gen)}
sondować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sondować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {comprepnp(co do)}
sondować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
sondować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
sortować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(na,acc)}
sortować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spacerować: _: : imperf: subj{np(str)} + {xp(perl)}
spacyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spacyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'zarodek',natr)}
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)}
spałaszować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
spałować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
spałować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
spamiętać: _: : perf: subj{np(str)} + {cp(int)}
spamiętać: _: : perf: subj{np(str)} + {cp(że)}
spamiętać: _: : perf: subj{np(str)} + obj{np(str)}
spanikować: _: : perf: subj{np(str)} + {cp(że)}
spanikować: _: : perf: subj{np(str)} + {or}
spaprać się: _: : perf: subj{np(str)} + {np(inst)}
spaprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sparafrazować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
sparafrazować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
sparafrazować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
sparodiować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak)} + {np(inst)}
sparodiować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
sparodiować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(jak)}
sparować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
sparować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
sparować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
spartaczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
spartolić się: _: : perf: subj{np(str)}
spartolić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
spasować: _: : perf: subj{np(str)} + {prepnp(z,gen)}
spasować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
spasować: _: : perf: subj{np(str)} + {xp(locat)}
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)}
spauperyzować się: _: : perf: subj{np(str)}
spauperyzować: _: : perf: subj{np(str)} + obj{np(str)}
spawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
spawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
spazmować: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
spazmować: _: : imperf: subj{np(str)} + {cp(że)}
spazmować: _: : imperf: subj{np(str)} + {or}
spazmować: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'myśl',atr)}
spazmować: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'widok',atr)}
spazmować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
specjalizować się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
specyfikować: _: : imperf: subj{np(str)} + obj{cp(int)}
specyfikować: _: : imperf: subj{np(str)} + obj{cp(że)}
specyfikować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
spenetrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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ęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
spęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
spęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
spęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
spęcznieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
spiec się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'rak',natr)}
spiec: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
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)}
spieniężyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
spieniężyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(locat)}
spieprzyć się: _: : perf: subj{np(str)} + {np(dat)}
spieprzyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
spieprzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
spieprzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
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)}
spiętrzać się: _: : imperf: subj{np(str)} + {np(dat)}
spiętrzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
spiętrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
spiętrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spiętrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spiętrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
spiętrzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(adl)} + {xp(locat)}
spiętrzyć się: _: : perf: subj{np(str)} + {xp(temp)}
spiętrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)} + {xp(adl)} + {xp(locat)}
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)}
spiknąć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
spiknąć się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
spiknąć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(z,inst)}
spiłować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spiłować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
spiłować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
spiłować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
spiorunować: _: : perf: subj{cp(gdy)} + {np(str)}
spiorunować: _: : perf: subj{cp(int)} + {np(str)}
spiorunować: _: : perf: subj{cp(jak)} + {np(str)}
spiorunować: _: : perf: subj{cp(kiedy)} + {np(str)}
spiorunować: _: : perf: subj{cp(że)} + {np(str)}
spiorunować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + obj{np(str)}
spiorunować: _: : perf: subj{np(str)} + obj{np(str)} + {np(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)}
spiskować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
spiskować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
spiskować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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)}
splajtować: _: : perf: subj{np(str)} + {prepnp(na,loc)}
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)}
spleśnieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
spleśnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spleśnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
spleśnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spleśnieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
splugawić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
splugawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
splugawić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
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łatać: _: : perf: subj{np(str)} + obj{lexnp(str,_,'figiel',atr)} + {np(dat)}
spłatać: _: : perf: subj{np(str)} + obj{lexnp(str,_,'psikus',atr)} + {np(dat)}
spłatać: _: : perf: subj{np(str)} + obj{lexnp(str,_,'żart',atr)} + {np(dat)}
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łowieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
spłowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
spłowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spłowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
spłowieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
spłukać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
spłukać się: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
spłukać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
spłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
spłukiwać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
spłukiwać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
spłukiwać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
spłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
spłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
spochmurnieć: _: : perf: subj{np(str)} + {np(dat)}
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)}
spodlić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
spodlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
spokornieć: _: : perf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',natr)}
spokornieć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
spokornieć: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
spokornieć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
spokornieć: _: : perf: subj{np(str)} + {xp(mod)}
spokornieć: _: : perf: subj{np(str)} + {xp(temp)}
spokrewnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
spokrewnić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
spolaryzować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
spolaryzować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
spolaryzować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)}
spolaryzować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
spolaryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc)}
spolaryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,loc)}
spoliczkować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
spoliczkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spolonizować się: _: : perf: subj{np(str)}
spolonizować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)} + {np(dat)}
spolszczyć się: _: : perf: subj{np(str)}
spolszczyć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
sponiewierać się: _: : perf: subj{np(str)}
sponiewierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
sponsorować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sponsorować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
spopielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
spopielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
spopielać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
spopielać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spopielić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
spopielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spopielić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
sposępnieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
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)}
spotnieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
spotwarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
spotwarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
spoufalać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
spoufalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
spoufalić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
spoufalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
spowszednieć: _: : perf: subj{cp(int)} + {np(dat)}
spowszednieć: _: : perf: subj{cp(że)} + {np(dat)}
spowszednieć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
sprać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
sprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
sprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
sprasować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
sprasować się: _: : perf: subj{np(str)} + {xp(mod)}
sprasować: _: : perf: subj{E} + obj{np(str)} + {prepnp(na,acc)}
sprasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
sprasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
sprasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
sprężynować: _: : imperf: subj{np(str)} + {xp(adl)}
sprężynować: _: : imperf: subj{np(str)} + {xp(mod)}
sprofanować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
sprofilować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprofilować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
sprokurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
spruć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
spruć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
sprzedać się: _: : perf: subj{np(str)} + {np(dat)}
sprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
sprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
sprzedawać się: _: : imperf: subj{np(str)} + {np(dat)}
sprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
sprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
sprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
sprzykrzyć się: _: : perf: controller{np(dat)} + controllee{infp(imperf)}
sprzykrzyć się: _: : perf: {np(dat)} + {xp(locat)}
sprzykrzyć się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
sprzymierzyć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
sprzysięgnąć się: _: : perf: subj{np(str)} + {cp(żeby)}
sprzysięgnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
sprzysięgnąć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
spuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spudłować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
spudłować: _: : perf: subj{np(str)} + obj{np(str)}
spudłować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
spuentować: _: : perf: subj{np(str)} + {cp(że)}
spuentować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
spuentować: _: : perf: subj{np(str)} + {or}
spulchniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
spulchnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spurpurowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
spurpurowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spurpurowieć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(na,loc,sg,'twarz',natr)}
spurpurowieć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(na,loc,sg,'twarz',natr)}
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)}
srebrzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
srebrzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
srożyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
srożyć się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
srożyć się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
srożyć: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
stanąć: _: : perf: {np(dat)} + {np(gen)}
stanąć: _: : perf: {prepadjp(na,loc)}
stanąć: _: : perf: {prepnp(na,loc); prepncp(na,loc,że); prepncp(na,loc,żeby)}
stanąć: _: : perf: subj{lexnp(str,pl,'oko',natr)} + {np(dat)} + {preplexnp(w,acc,sg,'słup',natr)}
stanąć: _: : perf: subj{lexnp(str,pl,'świeczka',natr)} + {np(dat)} + {preplexnp(w,loc,pl,'oko',natr)}
stanąć: _: : perf: subj{lexnp(str,sg,'język',natr)} + {np(dat)} + {lexnp(inst,sg,'kołek',natr)}
stanąć: _: : perf: subj{np(str)} + {lexnp(gen,sg,'słupek',natr)}
stanąć: _: : perf: subj{np(str)} + {lexnp(inst,sg,'sztorc',natr)}
stanąć: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stanąć: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
stanąć: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stanąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
stanąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
stanąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
stanąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)} + {fixed('dęba')}
stanąć: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',atr)}
stanąć: _: : perf: subj{np(str)} + {preplexnp(w,acc,pl,'szranki',atr)}
stanąć: _: : perf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',ratr)}
stanąć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
stanąć: _: : perf: subj{np(str)} + {prepnp(między,inst)}
stanąć: _: : perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
stanąć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)} + {lexnp(inst,sg,'mur',natr)}
stanąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,sg,'otwór',natr)}
stanąć: _: : perf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że)}
stanąć: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
stanąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
stanąć: _: : perf: subj{np(str)} + {prepnp(wobec,gen)}
stanąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(inst,sg,'mur',natr)}
standaryzować: _: : _: subj{np(str)} + obj{np(str)}
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(_)}
staranować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
stargać się: _: : perf: subj{np(str)}
stargać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
startować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
startować: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
startować: _: : imperf: subj{np(str)} + {xp(abl)}
starzeć się: _: : imperf: subj{np(str)} + {advp(misc)}
statuować: _: : imperf: subj{np(str)} + obj{cp(int)}
statuować: _: : imperf: subj{np(str)} + obj{cp(że)}
statuować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
stawić się: _: : perf: subj{np(str)} + {np(dat)}
stawić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
stawić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
stawić się: _: : perf: subj{np(str)} + {xp(adl)}
stawić się: _: : perf: subj{np(str)} + {xp(locat)}
stawić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'czoło',natr)}
stawić: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'czoło',natr)}
stawić: _: : perf: subj{np(str)} + obj{lexnp(gen,sg,'opór',atr)} + {np(dat)}
stawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
stchórzyć: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
stemplować: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
stemplować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
stenografować: _: : imperf: subj{np(str)} + obj{np(str)}
stenografować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
stenografować: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
sterać się: _: : perf: subj{np(str)} + {np(inst)}
sterać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
sterać: _: : perf: subj{np(str)} + {np(inst)} + {np(str)}
sterać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
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)}
sterylizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sterylizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
sterylizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
sterylizować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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ępiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
stępiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
stępiać się: _: : imperf: subj{np(str)} + {xp(locat)}
stępiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
stępiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
stępić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
stępić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
stępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
stępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
stępić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
stępieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
stępieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
stępieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
stępieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
stępieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stęsknić się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,żeby)}
stęsknić się: _: : perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
stężeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
stężeć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
stężeć: _: : perf: subj{np(str)} + {prepnp(na,loc)}
stężeć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
stłamsić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
stłoczyć się: _: : perf: subj{np(str)} + {xp(locat)}
stłoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
stołować się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
stołować się: _: : imperf: subj{np(str)} + {xp(locat)}
stołować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
stopniować się: _: : imperf: subj{np(str)}
stopniować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
stopować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
stopować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
stopować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
storpedować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
strawić się: _: : perf: subj{np(str)}
strawić się: _: : perf: subj{np(str)} + {np(inst)}
strawić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
strawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
strawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
strawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
strawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,żeby)}
strawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
strawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
strawić: neg: : perf: subj{np(str)} + {cp(gdy)}
strawić: neg: : perf: subj{np(str)} + {cp(int)}
strawić: neg: : perf: subj{np(str)} + {cp(jak)}
strawić: neg: : perf: subj{np(str)} + {cp(jeśli)}
strawić: neg: : perf: subj{np(str)} + {cp(kiedy)}
strawić: neg: : perf: subj{np(str)} + {cp(że)}
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)}
stremować się: _: : perf: subj{np(str)} + {cp(że)}
stremować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
stremować się: _: : perf: subj{np(str)} + {or}
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)}
stroić: _: : imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {refl}
stroić: _: : imperf: subj{np(str)} + {advp(misc)} + {refl}
stroić: _: : imperf: subj{np(str)} + {np(dat)} + {refl}
stroić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
stroić: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
stroić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
stroić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
stroić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
stroić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
stroić: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
stroić: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
stroić: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'żart',natr)}
stroić: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
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)}
struchleć: _: : perf: subj{np(str)} + {cp(int)}
struchleć: _: : perf: subj{np(str)} + {cp(że)}
struchleć: _: : perf: subj{np(str)} + {or}
struchleć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
struć się: _: : perf: subj{np(str)} + {np(inst)}
struć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
strudzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
strudzić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
strudzić się: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,int); prepncp(przy,loc,żeby)}
strudzić: _: : 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)}
strukturyzować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
strukturyzować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
strukturyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(str)}
strwożyć się: _: : perf: subj{np(str)} + {cp(int)}
strwożyć się: _: : perf: subj{np(str)} + {cp(że)}
strwożyć się: _: : perf: subj{np(str)} + {cp(żeby)}
strwożyć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
strwożyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
strwożyć się: _: : perf: subj{np(str)} + {or}
strwożyć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
strwożyć: _: : perf: subj{cp(że)} + {np(str)}
strwożyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
strwożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
strząsać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {xp(adl)}
strząsnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
strząsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {xp(adl)}
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)}
strzykać: _: : imperf: {np(dat)} + {xp(locat)}
strzykać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
strzykać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
strzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
strzyknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strzyknąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(perl)}
strzyknąć: _: : perf: subj{np(str)} + {np(str)} + {xp(adl)}
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)}
sturlać się: _: : perf: subj{np(str)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
stwardnieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
stwardnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
stwardnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,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)}
stygmatyzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
stygmatyzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
stygmatyzować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
stygmatyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
stygnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stygnąć: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
stygnąć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
stygnąć: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
stykać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
stykać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
stypizować: _: : _: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
stypizować: _: : _: subj{np(str)} + obj{np(str)} + {advp(misc)}
sublimować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
sublimować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
sublimować się: _: : imperf: subj{np(str)} + {xp(locat)}
sublimować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
sublimować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
sublimować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sublimować: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
sublimować: _: : imperf: subj{np(str)} + {xp(adl)}
sublimować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
subwencjonować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
suponować: _: : imperf: subj{np(str)} + {cp(że)}
suponować: _: : imperf: subj{np(str)} + {cp(żeby)}
suponować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)}
suponować: _: : imperf: subj{np(str)} + {or}
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)}
swawolić: _: : imperf: subj{np(str)}
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)}
swingować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
swingować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
swingować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
sygnować: _: : _: subj{np(str)} + obj{np(str)} + {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}
sylabizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
sylabizować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'nos',ratr)}
sylabizować: _: : imperf: subj{np(str)} + {or}
sylabizować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
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)}
symulować: _: : imperf: subj{np(str)} + {cp(że)}
symulować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
synchronizować się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
synchronizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
synchronizować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
syntetyzować się: _: : imperf: subj{np(str)}
syntetyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
syntetyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
syntetyzować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
szachować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
szargać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
szargać: _: : imperf: subj{np(str)} + obj{np(inst)}
szargać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); 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)}
szarzeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
szarzeć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
szarzeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
szarżować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
szarżować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
szastać się: _: : imperf: subj{np(str)} + {xp(locat)}
szastać: _: : imperf: subj{np(str)} + {np(inst)}
szatkować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
szatkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
szatkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
szatkować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
szczebiotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
szczebiotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
szczebiotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
szczebiotać: _: : imperf: subj{np(str)} + {np(dat)} + {nonch} + {xp(adl)}
szczebiotać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
szczebiotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
szczebiotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(jak)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {nonch}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(jak)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {nonch}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
szczebiotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
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)}
szczeknąć: _: : perf: subj{np(str)} + {np(str)}
szczeknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szczeknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
szczeknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
szczeknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
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ękać: _: : imperf: subj{np(str)} + {np(dat)}
szczękać: _: : imperf: subj{np(str)} + {np(inst)}
szczękać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
szczękać: _: : imperf: subj{np(str)} + {xp(locat)}
szczęknąć: _: : perf: subj{np(str)} + {np(dat)}
szczęknąć: _: : perf: subj{np(str)} + {np(inst)}
szczęknąć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
szczęknąć: _: : perf: subj{np(str)} + {xp(locat)}
szczęścić się: _: : imperf: {np(dat)} + {prepnp(w,loc)}
szczęścić się: _: : imperf: {np(dat)} + {prepnp(z,inst)}
szczęścić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
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)}
szczotkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szczotkować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
szczytować: _: : imperf: subj{np(str)} + {np(inst)}
szefować: _: : imperf: subj{np(str)} + {np(dat)}
szefować: _: : imperf: subj{np(str)} + {xp(locat)}
szeleścić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
szeleścić: _: : imperf: subj{np(str)} + {np(inst)}
szeleścić: _: : imperf: subj{np(str)} + {or}
szeleścić: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
szemrać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)} + {or}
szemrać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'ucho',ratr)} + {or}
szemrać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
szemrać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szemrać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)} + {cp(że)}
szemrać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
szemrać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
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)}
szeregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepadjp(na,acc)}
szeregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szeregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szeregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int)}
szeregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
szeregować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(względem,gen)}
szeregować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
szermować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
szermować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
szerzyć się: _: : imperf: subj{np(str)} + {xp(adl)}
szerzyć się: _: : imperf: subj{np(str)} + {xp(locat)}
szerzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
szerzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
szerzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
szkicować się: _: : imperf: subj{np(str)} + {np(dat)}
szkicować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc); prepnp(w,loc)}
szkicować: _: : imperf: subj{np(str)} + {refl}
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)}
szlajać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
szlajać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
szlajać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
szlajać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(dur)}
szlajać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
szlajać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(perl)}
szlifować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szlochać: _: : imperf: subj{np(str)} + {cp(int)}
szlochać: _: : imperf: subj{np(str)} + {cp(że)}
szlochać: _: : imperf: subj{np(str)} + {or}
szlochać: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
szlochać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
szlochać: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
szmuglować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
sznurować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sznurować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
szpachlować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szpanować: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
szpanować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
szpanować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
szpanować: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
szpecić: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
szpecić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szperać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
szpiegować: _: : imperf: subj{np(str)} + {np(dat)}
szpiegować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szpiegować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
szpiegować: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'rzecz',ratr)}
szpiegować: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
szpikować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
szpikować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
szprycować: _: : imperf: {np(inst)} + {np(str)} + {xp(locat)}
szprycować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
szprycować: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
szturmować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
szufladkować: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
szufladkować: _: : imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
szufladkować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
szufladkować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
szufladkować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szufladkować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
szufladkować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
szufladkować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
szufladkować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
szufladkować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
szufladkować: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
szufladkować: _: : imperf: subj{np(str)} + {prepnp(według,gen)} + {refl}
szufladkować: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
szufladkować: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
szwargotać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {or}
szwargotać: _: : 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)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
szwargotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
szwendać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
szwendać się: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
szydełkować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
ściemnieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
ściemnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ściemnieć: _: : perf: subj{np(str)} + {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)}
ścierpieć: _: : perf: subj{np(str)} + {cp(gdy)}
ścierpieć: _: : perf: subj{np(str)} + {cp(int)}
ścierpieć: _: : perf: subj{np(str)} + {cp(jak)}
ścierpieć: _: : perf: subj{np(str)} + {cp(kiedy)}
ścierpieć: _: : perf: subj{np(str)} + {cp(że)}
ścierpieć: _: : perf: subj{np(str)} + {cp(żeby)}
ścierpieć: _: : perf: subj{np(str)} + {np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)}
ścierpnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ścierpnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ścieśnić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
ścieśnić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
ścieśnić się: _: : perf: subj{np(str)} + {xp(locat)}
ścieśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ścieśnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ś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)}
ściszać się: _: : imperf: subj{np(str)}
ściszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ściszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ś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)}
ślimaczyć się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ślimaczyć się: _: : imperf: subj{np(str)} + {xp(dur)}
ś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)}
śmiecić: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
śmiecić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ś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)}
śnieżyć: _: : imperf: {np(dat)} + {xp(locat)}
śnieżyć: _: : imperf: subj{np(str)} + {np(dat)}
śnieżyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ś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)}
śrubować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
śrubować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ś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)}
świdrować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
świdrować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
świdrować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
świdrować: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'wylot',natr)}
ś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)}
świergotać: _: : imperf: subj{np(str)} + {cp(że)}
świergotać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(adl)}
świergotać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
świergotać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
świerzbić: _: : imperf: controller{np(str)} + controllee{infp(_)}
świerzbić: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
świerzbić: _: : imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
świerzbić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
świerzbić: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
święcić się: _: : imperf: subj{np(str)}
święcić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
święcić: _: : imperf: subj{np(str)} + obj{np(str)}
ś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)}
świntuszyć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
świntuszyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
świntuszyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
świntuszyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
świntuszyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
świntuszyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
świntuszyć: _: : 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)}
świntuszyć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
świntuszyć: _: : imperf: subj{np(str)} + {xp(locat)}
świrować: _: : imperf: subj{np(str)} + {cp(że)}
świrować: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
świrować: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
świrować: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
świsnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
świsnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
świstać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
świstać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
świstać: _: : imperf: subj{np(str)} + {or}
świszczeć: _: : imperf: subj{np(str)} + {xp(locat)}
świszczeć: _: : imperf: {xp(locat)}
ś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)}
tajać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
tajać: _: : imperf: subj{np(str)} + {prepnp(pod,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)}
tamować się: _: : imperf: subj{np(str)} + {np(inst)}
tamować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
tamować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
tanieć: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
tankować: _: : imperf: subj{np(str)} + obj{np(str)} + {fixed('do pełna')}
tankować: _: : imperf: subj{np(str)} + obj{np(str)} + {fixed('pod korek')}
tankować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
tankować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
tańcować: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
tańcować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
tańcować: _: : imperf: subj{np(str)} + {prepnp(wokół,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)}
tapicerować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
tarasować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
tarmosić się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
tarmosić się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
tarmosić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
tarmosić się: _: : imperf: subj{np(str)} + {xp(locat)}
tarmosić: _: : imperf: subj{np(str)} + {np(inst)}
tarmosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
tarmosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
tarmosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tarmosić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
tarmosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
tarmosić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
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)}
taszczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
tatuować się: _: : imperf: subj{np(str)}
tatuować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
tchórzyć: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
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)}
telegrafować: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {cp(int)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {cp(że)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)} + {xp(abl)}
telegrafować: _: : 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)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,acc)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {or}
telegrafować: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {cp(że)} + {xp(abl)}
telegrafować: _: : 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)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)} + {xp(abl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {or}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(abl)} + {xp(adl)}
telegrafować: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {or}
telepać się: _: : imperf: subj{np(str)} + {np(dat)}
telepać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
telepać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
telepać: _: : imperf: {np(inst)}
telepać: _: : imperf: {np(str)}
telepać: _: : imperf: subj{cp(że)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
telepać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
telepać: _: : imperf: subj{np(str)} + {np(inst)}
temperować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
temperować: _: : imperf: subj{np(str)} + {refl}
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)}
terkotać: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {cp(że)}
terkotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
terkotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
terkotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
terkotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
terkotać: _: : imperf: subj{np(str)} + {np(inst)}
terkotać: _: : imperf: subj{np(str)} + obj{or} + {np(dat)} + {prepnp(o,loc)}
terkotać: _: : imperf: subj{np(str)} + obj{or} + {prepnp(do,gen)} + {prepnp(o,loc)}
terkotać: _: : imperf: subj{np(str)} + obj{or} + {prepnp(o,loc)} + {prepnp(z,inst)}
terkotać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
terkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
terkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {cp(że)}
terkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
terkotać: _: : imperf: subj{np(str)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
terkotać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {cp(że)}
terkotać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
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)}
testować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
testować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
testować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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ępieć: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
tępieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',atr)}
tępieć: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
tępieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
tępieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
tępieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
tępieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
tężeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
tężeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
tężeć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
tężeć: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(mod)}
tężeć: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
tleć się: _: : imperf: subj{np(str)} + {xp(locat)}
tleć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
tleć: _: : imperf: subj{np(str)} + {np(inst)}
tleć: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
tlenić się: _: : imperf: subj{np(str)}
tlenić: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
tlenić: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
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łamsić się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
tłamsić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tłoczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
tłoczyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
tłoczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
tłoczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
tłoczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {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)}
tokować: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
tokować: _: : imperf: subj{np(str)} + {cp(int)}
tokować: _: : imperf: subj{np(str)} + {cp(jak)}
tokować: _: : imperf: subj{np(str)} + {cp(że)}
tokować: _: : imperf: subj{np(str)} + {or}
tokować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
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)}
tonizować się: _: : imperf: subj{np(str)}
tonizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
torpedować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
torturować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(dur)} + {xp(locat)}
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)}
trajkotać: _: : imperf: subj{np(str)}
trajkotać: _: : imperf: subj{np(str)} + {comprepnp(na temat)} + {cp(że)}
trajkotać: _: : imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
trajkotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
trajkotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
trajkotać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
trajkotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
trajkotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {or}
trajkotać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
trajkotać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {cp(że)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {or}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {cp(że)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {or}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
trajkotać: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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)}
transferować się: _: : _: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
transferować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
transformować się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
transformować się: _: : imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
transformować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
transformować się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
transformować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
transformować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
transformować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
transformować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
transkrybować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
transkrybować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
transkrybować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
transmitować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {fixed('na żywo')}
transmitować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
transponować się: _: : _: subj{np(str)} + {prepnp(na,acc)}
transponować: _: : _: subj,controller{np(str)} + controllee{xp(mod)} + {np(str)}
transponować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)} + {xp(perl)}
transponować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
transponować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
transponować: _: : _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
transponować: _: : _: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {refl}
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)}
trawersować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
trawestować: _: : imperf: subj{np(str)} + obj{np(str)}
trawić się: _: : imperf: subj{np(str)}
trawić się: _: : imperf: subj{np(str)} + {np(inst)}
trawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
trawić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
trawić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
trawić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
trawić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,żeby)}
trawić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
trawić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
trawić: neg: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
trawić: neg: : imperf: subj{np(str)} + {cp(gdy)}
trawić: neg: : imperf: subj{np(str)} + {cp(jak)}
trawić: neg: : imperf: subj{np(str)} + {cp(jeśli)}
trawić: neg: : imperf: subj{np(str)} + {cp(kiedy)}
trawić: neg: : imperf: subj{np(str)} + {cp(że)}
trawić: neg: : imperf: subj{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)}
trąbić: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
trąbić: _: : imperf: subj{np(str)} + {cp(int)} + {xp(abl)}
trąbić: _: : imperf: subj{np(str)} + {cp(int)} + {xp(adl)}
trąbić: _: : imperf: subj{np(str)} + {cp(int)} + {xp(locat)}
trąbić: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(abl)}
trąbić: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(adl)}
trąbić: _: : imperf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
trąbić: _: : imperf: subj{np(str)} + {cp(że)} + {xp(abl)}
trąbić: _: : imperf: subj{np(str)} + {cp(że)} + {xp(adl)}
trąbić: _: : imperf: subj{np(str)} + {cp(że)} + {xp(locat)}
trąbić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
trąbić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
trąbić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
trąbić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
trąbić: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,_,'ucho',atr)}
trąbić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
trąbić: _: : imperf: subj{np(str)} + {np(inst)}
trąbić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
trąbić: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(abl)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(adl)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
trąbić: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
trąbić: _: : imperf: subj{np(str)} + {xp(abl)} + {or}
trąbić: _: : imperf: subj{np(str)} + {xp(adl)} + {or}
trąbić: _: : imperf: subj{np(str)} + {xp(locat)} + {or}
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)}
tresować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
tresować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
tresować: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
tresować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
troić się: _: : imperf: {np(dat)} + {preplexnp(w,loc,pl,'źrenica',natr)}
troić się: _: : imperf: {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
troić się: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
troić się: _: : imperf: subj{np(str)} + {cp(żeby)}
troić się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'ręka',natr)}
troić się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
troić: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
troskać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
troskać się: _: : imperf: subj{np(str)} + {cp(int)}
troskać się: _: : imperf: subj{np(str)} + {cp(że)}
troskać się: _: : imperf: subj{np(str)} + {cp(żeby)}
troskać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
troskać się: _: : imperf: subj{np(str)} + {or}
troskać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
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)}
truchleć: _: : imperf: subj{np(str)} + {cp(int)}
truchleć: _: : imperf: subj{np(str)} + {cp(że)}
truchleć: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
truchleć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
truchleć: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
trwożyć się: _: : imperf: subj{np(str)} + {cp(int)}
trwożyć się: _: : imperf: subj{np(str)} + {cp(że)}
trwożyć się: _: : imperf: subj{np(str)} + {cp(żeby)}
trwożyć się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
trwożyć się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
trwożyć się: _: : imperf: subj{np(str)} + {or}
trwożyć się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
trwożyć: _: : imperf: subj{cp(że)} + {np(str)}
trwożyć: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
trwożyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
trysnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
trysnąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
trysnąć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
tryumfować: _: : imperf: subj{np(str)} + {cp(że)}
tryumfować: _: : imperf: subj{np(str)} + {np(inst)}
tryumfować: _: : imperf: subj{np(str)} + {or}
tryumfować: _: : imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
trywializować się: _: : imperf: subj{np(str)}
trywializować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
trzebić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
trzepotać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
trzepotać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
trzepotać: _: : imperf: subj{np(str)} + {np(inst)}
trzepotać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
trzepotać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
trzeszczeć: _: : imperf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
trzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
trzeszczeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
trzeszczeć: _: : imperf: subj{np(str)} + {np(inst)}
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)}
trzymać się: _: : imperf: subj{np(str)} + {np(gen)} + {np(inst)}
trzymać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
trzymać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
trzymać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
trzymać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
trzymać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
trzymać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
trzymać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
trzymać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
trzymać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
trzymać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
trzymać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
tuczyć się: _: : imperf: subj{np(str)} + {np(inst)}
tuczyć się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
tuczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tuczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
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)}
tułać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
tułać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
tułać się: _: : imperf: subj{np(str)} + {xp(perl)}
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)}
turkotać: _: : imperf: subj{np(str)} + {np(inst)}
turkotać: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
turkotać: _: : imperf: subj{np(str)} + {xp(locat)}
turkotać: _: : imperf: subj{np(str)} + {xp(mod)}
turlać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
turlać się: _: : imperf: subj{np(str)} + {np(inst)}
turlać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
turlać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
turlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
turlać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
tuszować: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(inst)}
tuszować: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(inst)}
tuszować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,że)}
tuszować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
twardnieć: _: : imperf: subj{np(str)} + {np(dat)}
twardnieć: _: : imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
twardnieć: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
twardnieć: _: : imperf: subj{np(str)} + {prepnp(od,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)}
tyczyć się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
tyczyć: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
tyczyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
tynkować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
tyranizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tytułować się: _: : imperf: subj{np(str)} + {np(inst)}
tytułować się: _: : imperf: subj{np(str)} + {or}
tytułować się: _: : imperf: subj{np(str)} + {prepnp(jako,str)}
tytułować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tytułować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(jako,str)}
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)}
uargumentować: _: : perf: subj{np(str)} + {cp(int)}
uargumentować: _: : perf: subj{np(str)} + {cp(że)}
uargumentować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uargumentować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
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)}
ubabrać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
ubabrać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
ubabrać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ubabrać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ubabrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ubabrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ubarwiać się: _: : imperf: subj{np(str)} + {np(inst)}
ubarwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubarwić się: _: : perf: subj{np(str)} + {np(inst)}
ubarwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubawić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
ubawić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ubawić się: _: : perf: subj{np(str)} + {preplexnp(po,acc,pl,'pacha',atr)}
ubawić: _: : perf: subj{cp(int)} + {np(str)}
ubawić: _: : perf: subj{cp(że)} + {np(str)}
ubawić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
ubawić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
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łasnowolniać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
ubezwłasnowolniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubezwłasnowolnić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ubezwłasnowolnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubić się: _: : perf: subj{np(str)}
ubić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
ubijać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
ubijać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
ubijać: _: : imperf: subj{np(str)} + obj{lexnp(str,_,'interes',atr)} + {prepnp(z,inst)}
ubijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
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)}
ubłagać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
ubłagać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
ubłocić się: _: : perf: subj{np(str)}
ubłocić: _: : perf: subj{np(str)} + obj{np(str)}
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żeć: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
ubożyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ubóstwiać: _: : imperf: subj,controller{np(str)} + controllee{infp(imperf)}
ubóstwiać: _: : imperf: subj{np(str)} + {cp(gdy)}
ubóstwiać: _: : imperf: subj{np(str)} + {cp(jak)}
ubóstwiać: _: : imperf: subj{np(str)} + {cp(kiedy)}
ubóstwiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
ubóstwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ubóstwić: _: : perf: subj{np(str)} + obj{np(str)}
ubóstwić: _: : perf: subj{np(str)} + {refl}
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)}
ubrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
ubrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ubrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
ubzdurać się: _: : perf: controller{np(dat)} + controllee{infp(_)}
ubzdurać się: _: : perf: {np(dat)} + {cp(że)}
ubzdurać się: _: : perf: subj{np(str); ncp(str,że)} + {np(dat)}
ubzdurać: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(dat,_,'sobie',natr)}
ubzdurać: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'sobie',natr)}
ubzdurać: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'sobie',natr)}
ubzdurać: _: : perf: subj{np(str)} + {np(str); ncp(str,że)} + {lexnp(dat,_,'sobie',natr)}
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)}
ucapić się: _: : perf: subj{np(str)} + {np(gen)} + {np(inst)}
ucapić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ucapić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ucharakteryzować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {refl}
ucharakteryzować: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {refl}
ucharakteryzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
ucharakteryzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
ucharakteryzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
ucharakteryzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,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)}
uciec się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
uciec się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
uciec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
uciec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
uciec: _: : perf: subj{np(str)} + {prepnp(do,gen)}
uciec: _: : perf: subj{np(str)} + {prepnp(od,gen)}
uciec: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
uciec: _: : perf: subj{np(str)} + {prepnp(z,inst)}
uciekać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
uciekać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
uciekać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
uciekać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
uciekać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
uciekać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
uciekać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
uciekać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ucieleśniać: _: : imperf: subj{np(str)} + obj{np(str)}
ucieleśnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
ucieleśnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
uciskać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
uciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {fixed('miejsce przy miejscu')}
uciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(str)} + {xp(adl)}
uciskać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uciskać: _: : 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)}
uczepić się: _: : perf: subj{np(str)} + {np(gen)}
uczepić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
uczepić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
uczłowieczać się: _: : imperf: subj{np(str)}
uczłowieczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uczłowieczyć się: _: : perf: subj{np(str)}
uczłowieczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
udaremniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
udeptać się: _: : perf: subj{np(str)}
udeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
udławić się: _: : perf: subj{np(str)} + {np(inst)}
udławić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
udławić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
udobruchać się: _: : perf: subj{np(str)}
udobruchać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
udobruchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
udramatyzować: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
udziwnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
udźwignąć: _: : perf: subj{np(str)} + obj{np(str)}
uelastyczniać się: _: : imperf: subj{np(str)}
uelastyczniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uelastycznić się: _: : perf: subj{np(str)}
uelastycznić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
ufarbować się: _: : perf: subj{np(str)} + {advp(misc)}
ufarbować się: _: : perf: subj{np(str)} + {np(inst)}
ufarbować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
ufarbować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)}
ufarbować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ufarbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
ufarbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ufarbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
ufortyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
ufortyfikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ufortyfikować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
ufryzować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {refl}
ufryzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(inst)}
ufundować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ufundować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
uganiać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(za,inst)}
uganiać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(locat)}
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)}
ugaszczać się: _: : imperf: subj{np(str)} + {np(inst)}
ugaszczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ugaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
ugłaskać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ugniatać się: _: : imperf: subj{np(str)}
ugniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ugniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ugniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ugniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
ugościć się: _: : perf: subj{np(str)} + {np(inst)}
ugościć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ugościć: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
ugościć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
ugrać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,inst)}
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)}
ujadać: _: : imperf: subj{np(str)} + {or}
ujadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
ujadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
ujadać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
ujadać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
ujadać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
ujarzmiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ujarzmić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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}
ujechać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(gdy)} + {advp(misc)}
ujechać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(kiedy)} + {advp(misc)}
ujechać: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
ujechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(gdy)}
ujechać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(kiedy)}
ujechać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ujechać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
ujechać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
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)}
ujędrniać się: _: : imperf: subj{np(str)} + {np(dat)}
ujędrniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
ujść: _: : perf: controller{np(dat)} + controllee{infp(_)}
ujść: _: : perf: subj,controller{cp(że)} + controllee{prepnp(za,acc)}
ujść: _: : perf: subj,controller{infp(_)} + controllee{prepnp(za,acc)}
ujść: _: : perf: subj,controller{np(str)} + controllee{prepadjp(za,acc)}
ujść: _: : perf: subj,controller{np(str)} + controllee{prepnp(za,acc)}
ujść: _: : perf: subj{np(str)} + {np(dat)} + {fixed('na sucho')}
ujść: _: : perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'płaz',natr)}
ujść: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ujść: _: : perf: subj{np(str)} + {xp(abl)}
ukamienować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
ukartować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
ukartować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
ukartować: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
ukatrupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
ukierunkować się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
ukierunkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
ukierunkowywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
ukierunkowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uklepać się: _: : perf: subj{np(str)}
uklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uklęknąć: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
uklęknąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
uklęknąć: _: : perf: subj{np(str)} + {xp(locat)}
uklęknąć: _: : perf: subj{np(str)} + {xp(mod)}
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)}
ukłonić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(od,gen)}
ukłonić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
ukłonić się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'pas',natr)}
ukłonić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
ukłuć: _: : perf: {np(str)} + {xp(locat)}
ukłuć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
ukłuć: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
ukłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uknuć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
uknuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
uknuć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
uknuć: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
ukochać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
ukoić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
ukoić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ukoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ukołysać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ukołysać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ukonkretnić się: _: : perf: subj{np(str)}
ukonkretnić: _: : perf: subj{np(str)} + {cp(że)}
ukonkretnić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
ukontentować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ukontentować: _: : perf: subj{cp(int)} + {np(str)}
ukontentować: _: : perf: subj{cp(że)} + {np(str)}
ukontentować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
ukontentować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
ukorzeniać się: _: : imperf: subj{np(str)}
ukorzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ukorzenić się: _: : perf: subj{np(str)} + {xp(locat)}
ukorzenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ukorzyć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
ukorzyć się: _: : perf: subj{np(str)} + {prepnp(za,acc)}
ukorzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
ukroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ukrócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ukruszyć się: _: : perf: subj{np(str)} + {np(dat)}
ukruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ukruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
ukuć się: _: : perf: subj{np(str)} + {xp(locat)}
ukuć się: _: : perf: subj{np(str)} + {xp(temp)}
ukuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat); prepnp(dla,gen)} + {prepnp(z,gen)}
ukwiecić się: _: : perf: subj{np(str)} + {advp(misc)}
ukwiecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ulać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ulać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
ulać: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(z,gen)}
ulać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ulać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
ulatniać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ulatywać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ulatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(przez,acc)} + {xp(abl)} + {xp(adl)}
ulatywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
ulecieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ulecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(przez,acc)} + {xp(abl)} + {xp(adl)}
ulecieć: _: : perf: subj{np(str)} + {prepnp(z,inst)}
uleczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
uleczyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(za,inst,sg,'pomoc',ratr)} + {refl}
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)}
ulewać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ulewać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
ulewać się: _: : imperf: subj{np(str)} + {xp(perl)}
ulewać: _: : imperf: subj{np(str)} + {np(inst)}
ulewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ulewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ulewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ulewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
uleżeć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
uleżeć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(dur)}
uleżeć: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
ulęknąć się: _: : perf: subj{np(str)} + {cp(int)}
ulęknąć się: _: : perf: subj{np(str)} + {cp(że)}
ulęknąć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
ulitować się: _: : perf: subj{np(str)} + {or}
ulitować się: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
ulitować się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
ulizać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
ulizać: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)}
ulizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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ładzić się: _: : perf: subj{np(str)}
uładzić: _: : perf: subj{np(str)} + obj{np(str)}
ułagodzić się: _: : perf: subj{np(str)}
ułagodzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
ułagodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ułamać się: _: : perf: subj{np(str)} + {np(dat)}
ułamać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
ułamać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
ułamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ułamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
ułamać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ułaskawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ułaskawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ułaskawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
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)}
umaić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
umartwiać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
umartwiać się: _: : imperf: subj{np(str)} + {cp(int)}
umartwiać się: _: : imperf: subj{np(str)} + {cp(że)}
umartwiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
umartwiać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
umarzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
umasowić się: _: : perf: subj{np(str)}
umasowić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
umazać się: _: : perf: subj{np(str)} + {np(inst)}
umazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umeblować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umęczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
umęczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)}
umiędzynarodowić się: _: : perf: subj{np(str)}
umiędzynarodowić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
umizgać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
umizgiwać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
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)}
umoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
umoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umoczyć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
umoczyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
umorzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
umościć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
umościć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umościć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
umościć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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}
umuzykalniać się: _: : imperf: subj{np(str)}
umuzykalniać: _: : imperf: subj{np(str)} + obj{np(str)}
umuzykalnić się: _: : perf: subj{np(str)}
umuzykalnić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
umyślić: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
umyślić: _: : perf: subj{np(str)} + {cp(int)}
umyślić: _: : perf: subj{np(str)} + {cp(że)}
umyślić: _: : perf: subj{np(str)} + {cp(żeby)}
umyślić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
umyślić: _: : perf: subj{np(str)} + {or}
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)}
unaoczniać się: _: : imperf: subj{np(str)}
unaoczniać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
unaoczniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
unaoczniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
unaocznić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
unaocznić: _: : perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
unaocznić: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
unaocznić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
unicestwiać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
unicestwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
unicestwić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
unicestwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
unieruchamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
unieruchamiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
unieruchomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
unieruchomić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
unieszczęśliwiać: _: : imperf: subj{cp(gdy)} + obj{np(str)}
unieszczęśliwiać: _: : imperf: subj{cp(jeśli)} + obj{np(str)}
unieszczęśliwiać: _: : imperf: subj{cp(kiedy)} + obj{np(str)}
unieszczęśliwiać: _: : imperf: subj{cp(że)} + obj{np(str)}
unieszczęśliwiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
unieszczęśliwiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
unieszczęśliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
unieszczęśliwić: _: : perf: subj{cp(gdy)} + obj{np(str)}
unieszczęśliwić: _: : perf: subj{cp(jeśli)} + obj{np(str)}
unieszczęśliwić: _: : perf: subj{cp(kiedy)} + obj{np(str)}
unieszczęśliwić: _: : perf: subj{cp(że)} + obj{np(str)}
unieszczęśliwić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
unieszczęśliwić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
unieszczęśliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
unieszkodliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
unieszkodliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
unieść się: _: : perf: subj{np(str)} + {np(inst)}
unieść się: _: : perf: subj{np(str)} + {or}
unieść się: _: : perf: subj{np(str)} + {prepnp(nad,acc)}
unieść się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
unieść się: _: : perf: subj{np(str)} + {xp(adl)}
unieść się: _: : perf: subj{np(str)} + {xp(locat)}
unieść: _: : perf: subj{np(str)} + {np(str)} + {or}
unieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
unosić się: _: : imperf: subj{np(str)} + {np(inst)}
unosić się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
unosić się: _: : imperf: subj{np(str)} + {xp(locat)}
unosić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
unurzać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
unurzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uobecniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
uobecniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uobecnić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
uobecnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
uodporniać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
uodporniać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
uodporniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uodporniać: _: : 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)}
uosabiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
uosabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uosabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
upaćkać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
upaćkać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
upaćkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
upadlać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
upadlać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
upadlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
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)}
upakować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
upakować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upakować: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
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)}
upaprać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
upaprać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
upaprać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
upaprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
upełnomocnić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upełnomocnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
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ąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
upiąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
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}
upiększać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
upiększać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
upiększyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
upiększyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
upinać: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)} + {xp(locat)}
upinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
upinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
upinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
uplasować się: _: : perf: subj{np(str)} + {xp(locat)}
uplasować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
upleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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łynniać się: _: : imperf: subj{np(str)}
upłynniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
upłynnić się: _: : perf: subj{np(str)}
upłynnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
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)}
upodlić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
upodlić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
upodlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
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)}
upolityczniać się: _: : imperf: subj{np(str)}
upolityczniać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
upozorować: _: : perf: subj{np(str)} + {cp(że)}
upozorować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
upozorować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
upozować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {refl}
upozować: _: : perf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {refl}
upozować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
upozować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
upozować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
upozować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
uprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uprać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uprasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
uprawdopodobniać się: _: : imperf: subj{np(str)}
uprawdopodobniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
uprawdopodobniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(int)}
uprawdopodobniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(że)}
uprawdopodobniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
uprawdopodobniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uprawdopodobnić się: _: : perf: subj{np(str)}
uprawdopodobnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
uprawdopodobnić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(int)}
uprawdopodobnić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {cp(że)}
uprawdopodobnić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
uprawdopodobnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
uprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
uprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
uprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
uprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
uprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
uprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uprzątać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
uprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
uprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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}
uprzedmiotowić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
uprzyjemniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uprzyjemnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
uprzytamniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(int)}
uprzytamniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(że)}
uprzytamniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uprzytamniać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
uprzytamniać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
uprzytamniać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
uprzytamniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
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)}
uprzywilejować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uprzywilejowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
upstrzyć się: _: : perf: subj{np(str)} + {np(inst)}
upstrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
upublicznić: _: : perf: subj{np(str)} + obj{cp(że)}
upublicznić: _: : perf: subj{np(str)} + obj{np(str)}
upudrować: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
upudrować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
upudrować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
upudrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
upudrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upudrować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
urabiać się: _: : imperf: subj{np(str)} + {fixed('po łokcie')}
urabiać się: _: : imperf: subj{np(str)} + {fixed('po pachy')}
urabiać: _: : imperf: subj{np(str)} + {np(str)} + {lexnp(dat,_,'sobie',natr)} + {fixed('po łokcie')}
urabiać: _: : imperf: subj{np(str)} + {np(str)} + {lexnp(dat,_,'sobie',natr)} + {fixed('po pachy')}
urabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
urabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
urabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
urabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uraczyć się: _: : perf: subj{np(str)} + {np(inst)}
uraczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
uradzić: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(z,inst)}
uradzić: _: : perf: subj{np(str)} + {np(str)}
uradzić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
uradzić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
uradzić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
urastać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(locat)}
urastać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
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}
urągać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
urągać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
urągać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
urlopować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
urlopować się: _: : perf: subj{np(str)} + {xp(dur)}
urlopować się: _: : perf: subj{np(str)} + {xp(locat)}
urlopować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
urlopować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
urlopować: _: : perf: subj{np(str)} + {xp(locat)}
urobić się: _: : perf: subj{np(str)} + {fixed('po łokcie')}
urobić się: _: : perf: subj{np(str)} + {fixed('po pachy')}
urobić: _: : perf: subj{np(str)} + {np(str)} + {lexnp(dat,_,'sobie',natr)} + {fixed('po łokcie')}
urobić: _: : perf: subj{np(str)} + {np(str)} + {lexnp(dat,_,'sobie',natr)} + {fixed('po pachy')}
urobić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
urobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urobić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
urobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
urobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
uronić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
uronić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
uronić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uronić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
uronić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
urosnąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
urosnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
urosnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
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}
urynkowić się: _: : perf: subj{np(str)}
urynkowić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
urżnąć się: _: : perf: subj{np(str)} + {np(inst)}
urżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urżnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
usiąść: _: : perf: subj{np(str)} + {prepnp(do,gen)}
usiąść: _: : perf: subj{np(str)} + {prepnp(na,loc)}
usiąść: _: : perf: subj{np(str)} + {xp(locat)}
usidlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
usidlać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
usidlać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
usidlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
usiedzieć: neg: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(dur)}
usiedzieć: neg: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(dur)}
usiedzieć: neg: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
usiłować: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
uskakiwać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
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}
uskładać się: _: : perf: subj{np(str)} + {np(dat)}
uskładać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
uskładać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
uskładać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
uskładać się: _: : perf: subj{np(str)} + {xp(locat)}
uskładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uskładać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uskładać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uskoczyć: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
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)}
uskuteczniać się: _: : imperf: subj{np(str)}
uskuteczniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
uskutecznić się: _: : perf: subj{np(str)}
uskutecznić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
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łuchać: _: : perf: subj{np(str)} + obj{np(gen)} + {cp(że)}
usługiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
usługiwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
usłużyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
usłużyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
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}
usmarować się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
usmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
usmolić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
usmolić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
usmolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
usmolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
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)}
usportowić się: _: : perf: subj{np(str)}
usportowić: _: : perf: subj{np(str)} + obj{np(str)}
usposabiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
usposabiać się: _: : imperf: subj{np(str)} + {prepnp(ku,dat)} + {advp(misc)}
usposabiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
usposabiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(ku,dat)} + {advp(misc)}
usposabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
usposabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat)} + {advp(misc)}
usposobić się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
usposobić się: _: : perf: subj{np(str)} + {prepnp(ku,dat)} + {advp(misc)}
usposobić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
usposobić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(ku,dat)} + {advp(misc)}
usposobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
usposobić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat)} + {advp(misc)}
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)}
ustawiać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
ustawiać się: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
ustawiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
ustawiać się: _: : imperf: subj{np(str)} + {xp(locat)}
ustawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
ustawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ustawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ustawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
ustawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ustawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ustawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ustawić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
ustawić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
ustawić się: _: : perf: subj{np(str)} + {xp(locat)}
ustawić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
ustawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ustawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ustawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ustawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ustawić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
ustroić się: _: : perf: subj{np(str)} + {np(inst)}
ustroić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
ustroić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
ustroić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
ustroić: _: : perf: subj{np(str)} + {advp(misc)} + {refl}
ustroić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
ustroić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
ustroić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ustroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ustroić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
ususzyć się: _: : perf: subj{np(str)} + {xp(locat)}
ususzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
usynowić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
uszanować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
uszanować: _: : perf: subj{np(str)} + obj{cp(że)}
uszanować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(u,gen)}
uszanować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uszanować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
uszczęśliwiać: _: : imperf: subj{cp(gdy)} + obj{np(str)}
uszczęśliwiać: _: : imperf: subj{cp(jeśli)} + obj{np(str)}
uszczęśliwiać: _: : imperf: subj{cp(kiedy)} + obj{np(str)}
uszczęśliwiać: _: : imperf: subj{cp(że)} + obj{np(str)}
uszczęśliwiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
uszczęśliwiać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
uszczęśliwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uszczęśliwić: _: : perf: subj{cp(gdy)} + obj{np(str)}
uszczęśliwić: _: : perf: subj{cp(jeśli)} + obj{np(str)}
uszczęśliwić: _: : perf: subj{cp(kiedy)} + obj{np(str)}
uszczęśliwić: _: : perf: subj{cp(że)} + obj{np(str)}
uszczęśliwić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
uszczęśliwić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
uszczęśliwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)}
uszczykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
uszczykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
uszczykiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
uszczypnąć: _: : perf: subj{np(str)} + {cp(int)} + {refl}
uszczypnąć: _: : perf: subj{np(str)} + {cp(żeby)} + {refl}
uszczypnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
uszczypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
uszczypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
uszczypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
uszczypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uszczypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
uszczypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {cp(żeby)}
uszczypnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
uszczypnąć: _: : perf: subj{np(str)} + {or}
uszeregować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
uszeregować się: _: : perf: subj{np(str)} + {xp(locat)}
uszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',ratr)}
uszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
uszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uszkadzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
uszkadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
uszminkować się: _: : perf: subj{np(str)}
uszminkować: _: : perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,sg,'siebie',natr)}
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)}
uszykować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
uszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uszykować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uszykować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
uszykować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
uszykować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
uszykować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
uszykować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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śmiać się: _: : perf: subj{np(str)} + {or}
uśmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
uśmiać się: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
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śmierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uśmierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(za,gen,sg,'pomoc',ratr)}
uśmierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uśmierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(za,gen,sg,'pomoc',ratr)}
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średniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
uśredniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
uśrednić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
uśrednić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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świadczyć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
utaić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
utaić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przed,inst)}
utaić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
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)}
utargować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {prepnp(z,inst)}
utargować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {xp(locat)}
utargować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)} + {prepnp(z,gen)} + {prepnp(z,inst)}
utargować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)} + {prepnp(z,gen)} + {xp(locat)}
utargować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)} + {xp(locat)}
utargować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)} + {cp(że)}
utemperować się: _: : perf: subj{np(str)}
utemperować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
utkwić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
utkwić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
utkwić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
utkwić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utleniać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
utleniać się: _: : imperf: subj{np(str)} + {advp(misc)}
utleniać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
utleniać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
utleniać: _: : imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
utleniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
utlenić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
utlenić się: _: : perf: subj{np(str)} + {advp(misc)}
utlenić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
utlenić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
utlenić: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
utlenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
utłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
utoczyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)}
utoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
utrafić: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
utrafić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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)}
utrudzić się: _: : perf: subj{np(str)} + {cp(żeby)}
utrudzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że); ncp(inst,żeby)}
utrudzić się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
utrudzić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
utrudzić się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
utrudzić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
utrudzić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
utrwalać się: _: : imperf: subj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(w,loc)}
utrwalać się: _: : imperf: subj{cp(int)} + {np(dat)} + {prepnp(w,loc)}
utrwalać się: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
utrwalać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
utrwalać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)}
utrwalać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {cp(że)}
utrwalać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
utrwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
utrwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
utrwalać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
utrwalać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(jak)}
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}
utuczyć się: _: : perf: subj{np(str)} + {np(inst)}
utuczyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
utuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
utuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
utuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
utuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
utulić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
utulić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
utulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
utulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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)}
utylizować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
utyskiwać: _: : imperf: subj{np(str)} + {cp(int)}
utyskiwać: _: : imperf: subj{np(str)} + {cp(że)}
utyskiwać: _: : imperf: subj{np(str)} + {or}
utyskiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
utyskiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(na,acc,int); prepncp(za,acc,że)}
utytłać się: _: : perf: subj{np(str)} + {np(inst)}
utytłać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
utytłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
utytłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uwalać się: _: : imperf: subj{np(str)} + {np(inst)}
uwalać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
uwalać się: _: : imperf: subj{np(str)} + {xp(adl)}
uwalać się: _: : imperf: subj{np(str)} + {xp(locat)}
uwalać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
uwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uwalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uwalać: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
uwalić się: _: : perf: subj{np(str)} + {np(inst)}
uwalić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
uwalić się: _: : perf: subj{np(str)} + {xp(adl)}
uwalić się: _: : perf: subj{np(str)} + {xp(locat)}
uwalić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
uwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uwalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uwalić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
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}
uwarzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)}
uwarzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
uwarzyć: _: : perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(z,gen)}
uwarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
uwarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
uwarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
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}
uwędzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
uwędzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uwiarygadniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
uwiarygadniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(wobec,gen)}
uwiarygadniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
uwiarygadniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(wobec,gen)} + {refl}
uwiarygadniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {cp(że)}
uwiarygadniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)} + {cp(że)}
uwiarygadniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {prepnp(przed,inst)}
uwiarygadniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {prepnp(wobec,gen)}
uwiarygadniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
uwiarygadniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(wobec,gen)}
uwiarygodniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
uwiarygodniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(wobec,gen)}
uwiarygodniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
uwiarygodniać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(wobec,gen)} + {refl}
uwiarygodniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {cp(że)}
uwiarygodniać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)} + {cp(że)}
uwiarygodniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {prepnp(przed,inst)}
uwiarygodniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {prepnp(wobec,gen)}
uwiarygodniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
uwiarygodniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(wobec,gen)}
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)}
uwidoczniać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uwidoczniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
uwidoczniać: _: : imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
uwidoczniać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
uwidoczniać: _: : 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)}
uwielbić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
uwielbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwielbić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
uwielbić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
uwielbić: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
uwieńczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uwierać: _: : imperf: subj{np(str)} + {np(inst)}
uwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
uwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {xp(mod)}
uwierać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
uwierać: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
uwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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łaczać: _: : imperf: subj{cp(gdy)} + {np(dat)}
uwłaczać: _: : imperf: subj{cp(int)} + {np(dat)}
uwłaczać: _: : imperf: subj{cp(jak)} + {np(dat)}
uwłaczać: _: : imperf: subj{cp(jeśli)} + {np(dat)}
uwłaczać: _: : imperf: subj{cp(kiedy)} + {np(dat)}
uwłaczać: _: : imperf: subj{cp(że)} + {np(dat)}
uwłaczać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
uwydatniać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
uwydatniać się: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
uwydatniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(int)}
uwydatniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(że)}
uwydatniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uwydatniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uwydatnić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
uwydatnić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
uwydatnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(int)}
uwydatnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(że)}
uwydatnić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uwydatnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uwypuklać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
uwypuklać się: _: : imperf: subj{np(str)} + {xp(locat)}
uwypuklać się: _: : imperf: subj{np(str)} + {xp(temp)}
uwypuklać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(int)}
uwypuklać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(że)}
uwypuklać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
uwypuklić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
uwypuklić się: _: : perf: subj{np(str)} + {xp(locat)}
uwypuklić się: _: : perf: subj{np(str)} + {xp(temp)}
uwypuklić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(int)}
uwypuklić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {cp(że)}
uwypuklić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
uwznioślać się: _: : imperf: subj{np(str)}
uwznioślać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
uwznioślić się: _: : perf: subj{np(str)}
uwznioślić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
uzewnętrzniać się: _: : imperf: subj{np(str)} + {np(inst)}
uzewnętrzniać się: _: : imperf: subj{np(str)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
uzewnętrzniać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(mod)}
uzewnętrzniać się: _: : imperf: subj{np(str)} + {xp(locat)}
uzewnętrzniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzewnętrzniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
uzewnętrzniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uzewnętrzniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
uzewnętrzniać: _: : imperf: subj{np(str)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
uzewnętrznić się: _: : perf: subj{np(str)} + {np(inst)}
uzewnętrznić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
uzewnętrznić się: _: : perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
uzewnętrznić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzewnętrznić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
uziemić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uziemić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uzmysławiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
uzmysławiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
uzmysławiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
uzmysławiać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
uzmysławiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uzmysłowić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
uzmysłowić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
uzmysłowić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
uzmysłowić: _: : perf: subj{np(str)} + {np(dat)} + {or}
uzmysłowić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
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}
uzurpować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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żalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int); cp(że)}
użalić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
użalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
użalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
użalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
użalić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
użalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
użalić się: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
użalić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(przed,inst)}
użalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int); cp(że)}
użalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
użądlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
użądlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
użerać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
użerać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
użerać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
użerać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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)}
użyźniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
użyźnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
wachlować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wachlować: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wachlować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wadzić się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
wadzić: _: : imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
wadzić: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
wadzić: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
wadzić: _: : imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
wadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
wagarować: _: : imperf: subj{np(str)}
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)}
walcować się: _: : imperf: subj{np(str)} + {xp(locat)}
walcować: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
walnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
walnąć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
walnąć się: _: : perf: subj{np(str)} + {xp(adl)}
walnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
walnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
walnąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
walnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
walnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
walnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
walnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
walnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
walnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
walnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
walnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(za,inst)}
walnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
wałkować: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wałkować: _: : imperf: subj{np(str)} + obj{np(str)}
wałkować: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
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}
warować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
warować: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(dur)} + {xp(locat)}
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}
warzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
warzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
warzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
warzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
warzyć się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
warzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
warzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
warzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
warzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
warzyć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
watować: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
watować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
wbiec: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)} + {xp(perl)}
wbiegać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)} + {xp(perl)}
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)}
wbudowywać się: _: : imperf: subj{np(str)} + {xp(adl)}
wbudowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
wbudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wbudowywać: _: : imperf: 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)}
wczepiać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wczepić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wczepić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wczepić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wczołgać się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(adl)} + {xp(perl)}
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}
wdmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wdusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wdusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
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)}
wdziać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
wdziewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
wedrzeć się: _: : perf: subj{np(str)} + {xp(adl)} + {xp(mod)} + {xp(perl)} + {xp(temp)}
wegetować: _: : imperf: subj{np(str)} + {xp(locat)}
wejrzeć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wejrzeć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
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)}
wentylować się: _: : imperf: subj{np(str)}
wentylować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
weprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
weprzeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
weprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
weprzeć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {cp(że)}
werbalizować: _: : imperf: subj{np(str)} + {cp(int)}
werbalizować: _: : imperf: subj{np(str)} + {cp(że)}
werbalizować: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
wessać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wessać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
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)}
wezbrać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(na,acc,sg,'myśl',atr)}
wezbrać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(na,acc,sg,'widok',atr)}
wezbrać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wezbrać: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'skutek',atr)}
wezbrać: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
wezbrać: _: : perf: subj{np(str)} + {preplexnp(w,loc,sg,'wynik',atr)}
wezbrać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wezbrać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wezbrać: _: : perf: subj{np(str)} + {prepnp(wskutek,gen)}
wezbrać: _: : perf: subj{np(str)} + {xp(abl)}
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)}
weżreć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
weżreć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
weżreć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
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)}
wgapiać się: _: : imperf: subj{np(str)} + {cp(jak)}
wgapiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wgapiać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wgłębiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wgłębiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wgłębić się: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wgłębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
wgramolić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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}
wieszczyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wieszczyć: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wieszczyć: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wieszczyć: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
wilgotnieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
wilgotnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wilgotnieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
windować się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
windować się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
windować się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
windować się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
windować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
windować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
windować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
windować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
windykować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
windykować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
windykować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
winszować: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
winszować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
winszować: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
winszować: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
winszować: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wionąć: _: : imperf: {np(inst)} + {prepnp(od,gen)}
wionąć: _: : imperf: {np(inst)} + {xp(abl)}
wionąć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wionąć: _: : imperf: subj{np(str)} + {xp(abl)}
wiosłować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wiosłować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
wiotczeć: _: : imperf: subj{np(str)}
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)}
wiwatować: _: : imperf: subj{np(str)} + {np(dat)}
wiwatować: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'cześć',ratr)}
wiwatować: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
wklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wklęsnąć się: _: : perf: subj{np(str)}
wklęsnąć: _: : perf: subj{np(str)} + {np(dat)}
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)}
wkomponować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wkomponować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wkomponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wkomponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wkomponowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wkomponowywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wkomponowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wkomponowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wkopać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wkopać się: _: : perf: subj{np(str)} + {xp(adl)}
wkopać się: _: : perf: subj{np(str)} + {xp(locat)}
wkopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wkopać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wkopać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wkopywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wkopywać się: _: : imperf: subj{np(str)} + {xp(adl)}
wkopywać się: _: : imperf: subj{np(str)} + {xp(locat)}
wkopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wkopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wkopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
wkuć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wkuć się: _: : perf: subj{np(str)} + {np(gen)}
wkuć się: _: : perf: subj{np(str)} + {prepnp(o,loc)}
wkuć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {xp(adl)}
wkuć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
wkuć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(adl)}
wkuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wkuć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wkuć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wkupić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wkupić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wkupywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wkupywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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)}
wkuwać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wkuwać się: _: : imperf: subj{np(str)} + {np(gen)}
wkuwać się: _: : imperf: subj{np(str)} + {prepnp(o,loc)}
wkuwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {xp(adl)}
wkuwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
wkuwać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {xp(adl)}
wkuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wkuwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wkuwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wlać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wlać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(part)} + {prepnp(do,gen)}
wlać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
wlać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
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)}
wlewać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
wlewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
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)}
wmanewrować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wmanewrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wmanewrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wmanewrować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wmarznąć: _: : perf: subj{np(str)} + {xp(adl)}
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)}
wnerwiać się: _: : imperf: subj{np(str)} + {cp(int)}
wnerwiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wnerwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
wnerwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wnerwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
wnerwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wnerwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
wnerwiać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wnerwiać: _: : imperf: subj{cp(gdy)} + {np(str)}
wnerwiać: _: : imperf: subj{cp(int)} + {np(str)}
wnerwiać: _: : imperf: subj{cp(jak)} + {np(str)}
wnerwiać: _: : imperf: subj{cp(jeśli)} + {np(str)}
wnerwiać: _: : imperf: subj{cp(kiedy)} + {np(str)}
wnerwiać: _: : imperf: subj{cp(że)} + {np(str)}
wnerwiać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
wnerwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wnerwić się: _: : perf: subj{np(str)} + {cp(int)}
wnerwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
wnerwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
wnerwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wnerwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
wnerwić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wnerwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
wnerwić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wnerwić: _: : perf: subj{cp(gdy)} + {np(str)}
wnerwić: _: : perf: subj{cp(int)} + {np(str)}
wnerwić: _: : perf: subj{cp(jak)} + {np(str)}
wnerwić: _: : perf: subj{cp(jeśli)} + {np(str)}
wnerwić: _: : perf: subj{cp(kiedy)} + {np(str)}
wnerwić: _: : perf: subj{cp(że)} + {np(str)}
wnerwić: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
wnerwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
wojażować: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wojażować: _: : imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wojażować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
wonieć: _: : imperf: controller{xp(locat)} + controllee{xp(mod)}
wonieć: _: : imperf: {np(inst)} + {xp(locat)}
wonieć: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
wonieć: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
wonieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
wonieć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
worać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
woskować: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
woskować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
wpakować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wpakować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpakować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wpakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpasować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wpasować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wpasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wpasowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wpasowywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wpasowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpasowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {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)}
wpełzać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wpełznąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
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)}
wpiąć się: _: : perf: subj{np(str)} + {xp(adl)}
wpiąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wpić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wpić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpieprzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wpieprzyć: _: : perf: subj{cp(gdy)} + {np(str)}
wpieprzyć: _: : perf: subj{cp(int)} + {np(str)}
wpieprzyć: _: : perf: subj{cp(jak)} + {np(str)}
wpieprzyć: _: : perf: subj{cp(jeśli)} + {np(str)}
wpieprzyć: _: : perf: subj{cp(kiedy)} + {np(str)}
wpieprzyć: _: : perf: subj{cp(że)} + {np(str)}
wpieprzyć: _: : 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)}
wpieprzyć: _: : perf: subj{np(str)} + {np(dat)}
wpieprzyć: _: : perf: subj{np(str)} + obj{np(str)}
wpierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wpierać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wpierać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wpierać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wpierać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wpierać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,acc)}
wpierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpierać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {cp(int)}
wpierać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {cp(że)}
wpierać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {or}
wpijać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wpijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpinać się: _: : imperf: subj{np(str)} + {xp(adl)}
wpinać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
wpompować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wpompować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
wprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wprzęgnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
wprzęgnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
wrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
wrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wrabiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wrabiać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
wrastać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,acc)}
wrastać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wrastać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)} + {xp(perl)}
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)}
wrobić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wrobić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wrobić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wrobić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wrodzić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wrodzić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wrosnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,acc)}
wrosnąć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wrosnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(pod,acc,sg,'ziemia',natr)}
wrosnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)} + {xp(perl)}
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)}
wryć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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}
wrzeć: _: : imperf: {comprepnp(na temat)} + {xp(locat)}
wrzeć: _: : imperf: {comprepnp(z powodu)} + {xp(locat)}
wrzeć: _: : imperf: {np(inst)} + {xp(locat)}
wrzeć: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
wrzeć: _: : imperf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {xp(locat)}
wrzeć: _: : imperf: {prepnp(z,gen)} + {xp(locat)}
wrzeć: _: : imperf: subj{cp(że)} + {xp(locat)}
wrzeć: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wrzeć: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
wrzeć: _: : imperf: subj{np(str)} + {cp(że)}
wrzeć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wrzeć: _: : imperf: subj{np(str)} + {np(inst)}
wrzeć: _: : imperf: subj{np(str)} + {or}
wrzeć: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wrzeć: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
wrzeć: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)}
wrzeć: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wrzeć: _: : imperf: {xp(locat)} + {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)}
wrzynać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
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)}
wsączać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(adl)} + {xp(perl)}
wsączać: _: : imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
wsączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsączać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wschodzić: _: : imperf: subj{np(str)} + {np(dat)}
wschodzić: _: : imperf: subj{np(str)} + {prepnp(dla,gen)}
wschodzić: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
wschodzić: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wschodzić: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wschodzić: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wschodzić: _: : imperf: subj{np(str)} + {xp(mod)}
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ółbrzmieć: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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ółdecydować: _: : imperf: subj{np(str)} + {comprepnp(co do)}
współdecydować: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
współdecydować: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
współdecydować: _: : imperf: subj{np(str)} + {cp(int)}
współdecydować: _: : imperf: subj{np(str)} + {cp(że)}
współdecydować: _: : imperf: subj{np(str)} + {cp(żeby)}
współdecydować: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
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ółprowadzić: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
współprowadzić: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
współprowadzić: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
współredagować: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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ółwystępować: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
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)}
wstać: _: : perf: subj{np(str)} + {np(inst)}
wstać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wstać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wstać: _: : perf: subj{np(str)} + {xp(abl)}
wstawać: _: : imperf: subj{np(str)} + {np(inst)}
wstawać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wstawać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wstawać: _: : imperf: subj{np(str)} + {xp(abl)}
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)}
wstrzelić: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(adl)}
wstrzelić: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
wstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wstrzelić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wstrzelić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(żeby)}
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}
wsysać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsysać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wszcząć się: _: : perf: subj{np(str)} + {xp(locat)}
wszcząć: _: : perf: subj{np(str)} + obj{np(str)}
wszczepiać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wszczepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wszczepić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wszczepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wszczynać się: _: : imperf: subj{np(str)} + {xp(locat)}
wszczynać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
wślizgiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wślizgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wśliznąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wtaczać się: _: : imperf: subj{np(str)} + {xp(locat)}
wtaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wtajemniczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wtajemniczać: _: : imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)} + {refl}
wtajemniczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wtajemniczyć: _: : perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)} + {refl}
wtapiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wtapiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wtapiać: _: : imperf: subj{np(str)} + obj{np(str)}
wtapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wtargnąć: _: : perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wtłaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wtłoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wtoczyć się: _: : perf: subj{np(str)} + {xp(adl)}
wtoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wtopić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wtopić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wtopić: _: : perf: subj{np(str)} + obj{np(str)}
wtopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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}
wtryniać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {xp(adl)}
wtryniać się: _: : imperf: subj{np(str)} + {or}
wtryniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wtryniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wtryniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wtrynić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {xp(adl)}
wtrynić się: _: : perf: subj{np(str)} + {or}
wtrynić się: _: : perf: subj{np(str)} + {xp(locat)}
wtrynić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wtrynić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wtrynić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
wulkanizować: _: : imperf: subj{np(str)} + obj{np(str)}
wwiercać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wwiercać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wwiercać się: _: : imperf: subj{np(str)} + {np(inst)} + {np(str)} + {xp(adl)}
wwiercać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wwieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wwozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyabstrahować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyabstrahować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyabstrahować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyabstrahować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyalienować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyalienować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyalienować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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}
wyasfaltować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
wybadać: _: : perf: subj{np(str)} + {cp(że)}
wybadać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
wybadać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wybadać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
wybawiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
wybawiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
wybawiać: _: : imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
wybawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wybawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
wybawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wybawiać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wybawiać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
wybawiać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wybawić się: _: : perf: subj{np(str)} + {np(inst)}
wybawić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
wybawić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
wybawić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
wybawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wybawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
wybawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wybawić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wybawić: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
wybawić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wybąkać: _: : perf: subj{np(str)} + {cp(int)}
wybąkać: _: : perf: subj{np(str)} + {cp(że)}
wybąkać: _: : perf: subj{np(str)} + {cp(żeby)}
wybąkać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
wybąkać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
wybąkać: _: : perf: subj{np(str)} + {or}
wybąknąć: _: : perf: subj{np(str)} + {cp(int)}
wybąknąć: _: : perf: subj{np(str)} + {cp(że)}
wybąknąć: _: : perf: subj{np(str)} + {cp(żeby)}
wybąknąć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
wybąknąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
wybąknąć: _: : perf: subj{np(str)} + {or}
wybebeszyć się: _: : perf: subj{np(str)}
wybebeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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)}
wybielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wybielać: _: : imperf: subj{np(str)} + {refl}
wybieleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wybielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wybielić: _: : perf: subj{np(str)} + {refl}
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}
wyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {advp(misc)}
wyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyblaknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(mod)}
wybłagać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {cp(że)}
wybłagać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {cp(żeby)}
wybłagać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)} + {cp(że)}
wybłagać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)} + {cp(żeby)}
wybłagać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(od,gen)}
wybłagać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(u,gen)}
wybłagać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(od,gen)}
wybłagać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
wybłagać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(na,loc)}
wybłagać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wybłagać: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(od,gen)} + {cp(że)}
wybłagać: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(od,gen)} + {cp(żeby)}
wybłagać: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)} + {cp(że)}
wybłagać: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)} + {cp(żeby)}
wybłagać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
wybłagać: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(żeby)}
wyborować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyborować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
wybrudzić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
wybrudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wybrukować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wybrzuszać się: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
wybrzuszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wybrzuszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
wybrzuszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
wybrzuszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wybrzuszać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wybrzuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wybrzuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
wybrzuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wybrzuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
wybrzuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
wybrzuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wybrzuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wybrzuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wybrzuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wybrzydzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
wybrzydzać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
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)}
wybudzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wybudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wybudzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wybudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {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)}
wyburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
wyburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
wybyć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wybywać: _: : imperf: subj{np(str)} + {xp(abl)}
wybywać: _: : imperf: subj{np(str)} + {xp(adl)}
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}
wychlapać się: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
wychlapać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wychlapać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(abl)}
wychlapać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
wychlapać się: _: : perf: subj{np(str)} + {or}
wychlapać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
wychlapać: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
wychlapać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wychlapać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
wychlapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(abl)}
wychlapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wychlapać: _: : perf: subj{np(str)} + {or}
wychlapać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
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łeptać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wychłodzić się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
wychłodzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wychłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wychłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wychłodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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)}
wychrypieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)} + {xp(adl)}
wychrypieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)} + {xp(adl)}
wychrypieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {xp(adl)}
wychrypieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)} + {xp(adl)}
wychrypieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {or}
wychrypieć: _: : perf: subj{np(str)} + {np(inst)} + {np(str)} + {prepnp(do,gen)}
wychrypieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(int)}
wychrypieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
wychrypieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
wychrypieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {or}
wychudnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wychudnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wychudnąć: _: : perf: subj{np(str)} + {xp(mod)}
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)}
wychynąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychynąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(locat)} + {xp(perl)}
wychynąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychynąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(locat)} + {xp(perl)}
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)}
wycieniować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wycieńczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
wycieńczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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}
wycierpieć się: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
wycierpieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wycierpieć się: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wycierpieć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(dla,gen)}
wycierpieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wycierpieć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
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)}
wyciosać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyciosać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
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)}
wycyganić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wycyganić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wycyzelować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyczarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyczarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wyczarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyczarować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyczarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyczarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wyczarowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyczarowywać: _: : 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)}
wyczekać się: _: : perf: subj{np(str)} + {cp(aż)}
wyczekać się: _: : perf: subj{np(str)} + {cp(int)}
wyczekać się: _: : perf: subj{np(str)} + {cp(jak)}
wyczekać się: _: : perf: subj{np(str)} + {cp(kiedy)}
wyczekać się: _: : perf: subj{np(str)} + {cp(że)}
wyczekać się: _: : perf: subj{np(str)} + {cp(żeby)}
wyczekać się: _: : perf: subj{np(str)} + {np(gen)}
wyczekać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wyczekać się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,aż); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,kiedy); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wyczekać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyczekać się: _: : perf: subj{np(str)} + {xp(dur)}
wyczekać: _: : perf: subj{np(str)} + {cp(aż)}
wyczekać: _: : perf: subj{np(str)} + {cp(int)}
wyczekać: _: : perf: subj{np(str)} + {cp(jak)}
wyczekać: _: : perf: subj{np(str)} + {cp(kiedy)}
wyczekać: _: : perf: subj{np(str)} + {cp(że)}
wyczekać: _: : perf: subj{np(str)} + {cp(żeby)}
wyczekać: _: : perf: subj{np(str)} + {np(gen)}
wyczekać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
wyczekać: _: : perf: subj{np(str)} + {prepnp(na,acc); 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)}
wyczekać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyczekać: _: : perf: subj{np(str)} + {xp(dur)}
wyczekiwać: _: : imperf: subj{np(str)} + {cp(aż)}
wyczekiwać: _: : imperf: subj{np(str)} + {cp(int)}
wyczekiwać: _: : imperf: subj{np(str)} + {cp(jak)}
wyczekiwać: _: : imperf: subj{np(str)} + {cp(kiedy)}
wyczekiwać: _: : imperf: subj{np(str)} + {cp(że)}
wyczekiwać: _: : imperf: subj{np(str)} + {cp(żeby)}
wyczekiwać: _: : imperf: subj{np(str)} + {np(gen)}
wyczekiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wyczekiwać: _: : imperf: subj{np(str)} + {prepnp(na,acc); 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)}
wyczekiwać: _: : imperf: subj{np(str)} + {xp(dur)}
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)}
wyczesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyczołgać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wyczulić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wyczulić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
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)}
wyczyścić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(z,gen)} + {refl}
wyczyścić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wyczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
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}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(int)} + {prepnp(z,gen)}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(z,gen)}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(żeby)} + {xp(locat)}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {comprepnp(na temat)} + {xp(locat)}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(o,loc)} + {xp(locat)}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {prepnp(z,gen)}
wyczytywać: _: : imperf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
wyczytywać: _: : imperf: subj{np(str)} + obj{nonch} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
wyczytywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int)}
wyczytywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
wyczytywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
wyczytywać: _: : imperf: subj{np(str)} + {xp(locat)} + {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ąż')}
wydalać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wydalać się: _: : imperf: subj{np(str)} + {xp(abl)}
wydalać się: _: : imperf: subj{np(str)} + {xp(adl)}
wydalać się: _: : imperf: subj{np(str)} + {xp(perl)}
wydalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wydalać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wydalać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydalić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wydalić się: _: : perf: subj{np(str)} + {xp(abl)}
wydalić się: _: : perf: subj{np(str)} + {xp(adl)}
wydalić się: _: : perf: subj{np(str)} + {xp(perl)}
wydalić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wydalić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wydalić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydarzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
wydarzać się: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
wydedukować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wydedukować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wydedukować: _: : perf: subj{np(str)} + {or}
wydedukować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wydedukować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wydedukować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wydedukować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(żeby2)}
wydedukować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wydedukować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wydedukować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wydedukować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(żeby2)}
wydekoltować się: _: : perf: subj{np(str)}
wydekoltować: _: : perf: subj{np(str)} + obj{np(str)}
wydelegować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wydelegować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wydepilować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
wydepilować się: _: : perf: subj{np(str)} + {np(inst)}
wydepilować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wydeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wydeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
wydeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wydeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
wydestylować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydestylować: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wydestylować: _: : perf: subj{np(str)} + {prepnp(w,loc)}
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}
wydorośleć: _: : perf: subj{np(str)}
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)}
wydostawać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wydostawać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)} + {xp(perl)}
wydostawać: _: : imperf: subj{np(str)} + {np(part)} + {prepnp(na,acc)}
wydostawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydostawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
wydrwić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wydrwiwać: _: : imperf: subj{np(str)} + obj{np(str)}
wydrzeć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
wydrzeć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wydrzeć się: _: : perf: subj{np(str)} + {prepnp(o,loc)}
wydrzeć się: _: : perf: subj{np(str)} + {xp(adl)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'ręka',ratr)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {or}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wydukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
wydukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
wydukać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)} + {cp(int)}
wydukać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)} + {cp(że)}
wydukać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)} + {or}
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}
wydusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(int)}
wydusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(że)}
wydusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {cp(int)}
wydusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {cp(że)}
wydusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {cp(żeby)}
wydusić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {or}
wydusić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(od,gen)}
wydusić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(z,gen)}
wydusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyduszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(int)}
wyduszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(że)}
wyduszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {cp(int)}
wyduszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {cp(że)}
wyduszać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {or}
wyduszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(od,gen)}
wyduszać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(z,gen)}
wyduszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
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)}
wydzierać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
wydzierać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wydzierać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wydzierać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
wydzierać się: _: : imperf: subj{np(str)} + {xp(adl)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'ręka',ratr)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {or}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydzierać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wydziergać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wydziergać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepadjp(z,gen)}
wydziergać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wydzierżawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wydzierżawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
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)}
wydziobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wydziobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
wydzwaniać: _: : imperf: subj{np(str)} + obj{np(str)}
wydzwaniać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wydzwonić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
wyekspediować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wyemancypować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyemancypować się: _: : perf: subj{np(str)} + {prepnp(spod,gen)}
wyemigrować: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wyemitować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyewoluować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {xp(temp)}
wyewoluować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)} + {xp(temp)}
wyfrunąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wygarnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wygarnąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wygarnąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
wygarnąć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wygarnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wygarnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wygarniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wygarniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wygarniać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wygarniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wygarniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wygarniać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
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)}
wyglansować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyglansować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
wygniatać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
wygniatać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygniatać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)} + {refl}
wygnieść się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wygnieść się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wygnieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
wygoić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
wygoić się: _: : perf: subj{np(str)} + controller{prepnp(na,loc)} + controllee{xp(mod)}
wygoić: _: : perf: subj{np(str)} + {np(str)}
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)}
wygotować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wygotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,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)}
wygramolić: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wygrawerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
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)}
wygrzać się: _: : perf: subj{np(str)} + {xp(locat)}
wygrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wygrzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wygrzać: _: : perf: subj{np(str)} + {xp(adl)}
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)}
wygrzewać się: _: : imperf: subj{np(str)} + {xp(locat)}
wygrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wygrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wygubić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wygubić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
wyimaginować: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
wyimaginować: _: : perf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyimaginować: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wyimaginować: _: : perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
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)}
wyjaskrawiać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
wyjednać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(od,gen)}
wyjednać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(u,gen)}
wyjednać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)} + {cp(że)}
wyjednać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)} + {cp(żeby)}
wyjednać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(u,gen)} + {cp(że)}
wyjednać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(u,gen)} + {cp(żeby)}
wyjeść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyjeździć się: _: : perf: subj{np(str)} + {fixed('konno')}
wyjeździć się: _: : perf: subj{np(str)} + {np(inst)}
wyjeździć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wyjeździć się: _: : perf: subj{np(str)} + {xp(locat)}
wyjeździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyjeździć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyjeździć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyjeździć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wyjęczeć: _: : perf: subj{np(str)} + {cp(int)}
wyjęczeć: _: : perf: subj{np(str)} + {cp(że)}
wyjęczeć: _: : perf: subj{np(str)} + {cp(żeby)}
wyjęczeć: _: : perf: subj{np(str)} + obj{np(str)}
wyjęczeć: _: : perf: subj{np(str)} + {or}
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)}
wyjrzeć: _: : perf: subj{np(str)} + {cp(int)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wykaligrafować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wykaligrafować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wykaligrafować: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wykaligrafować: _: : perf: subj{np(str)} + {np(dat)} + {or}
wykaligrafować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {or}
wykaligrafować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {or}
wykaligrafować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
wykaligrafować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wykaligrafować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wykalkulować: _: : perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
wykalkulować: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
wykalkulować: _: : perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wykalkulować: _: : perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
wykalkulować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,_,'siebie',natr)}
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)}
wykaraskać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wykaraskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
wykasować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wykasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykasować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wykastrować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
wykastrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
wykiełkować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
wykiełkować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wykiełkować: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
wykipieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wykipieć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(mod)}
wykiwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyklarować się: _: : perf: subj{cp(int)} + {np(dat)}
wyklarować się: _: : perf: subj{cp(że)} + {np(dat)}
wyklarować się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyklarować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyklarować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyklarować: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wyklarować: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyklarować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
wykleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykleić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wykleić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykleić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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łócać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
wykłócać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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)}
wykoleić się: _: : perf: subj{np(str)}
wykoleić: _: : perf: subj{np(str)} + obj{np(str)}
wykolejać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wykolejać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykołować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
wykoncypować: _: : perf: subj{np(str)} + {cp(int)}
wykoncypować: _: : perf: subj{np(str)} + {cp(że)}
wykoncypować: _: : perf: subj{np(str)} + {cp(żeby)}
wykoncypować: _: : perf: subj{np(str)} + obj{np(str)}
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}
wykopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wykopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wykopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wykopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykopywać: _: : imperf: subj{np(str)} + {xp(abl)} + {refl}
wykorzeniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wykorzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wykorzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykorzeniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykorzenić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wykorzenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wykorzenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykorzenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
wykosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wykosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wykosić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
wykosić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
wykoślawić się: _: : perf: subj{np(str)}
wykoślawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
wykrakać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wykrakać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wykrakać: _: : perf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,int); ncp(str,że)}
wykrakać: _: : perf: subj{np(str)} + {np(dat)} + {or}
wykrakać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
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)}
wykroczyć: _: : perf: subj{ncp(str,int); ncp(str,że)} + {prepnp(poza,acc)}
wykroczyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(poza,acc); prepncp(poza,acc,int); prepncp(poza,acc,że)}
wykroczyć: _: : perf: subj{np(str)} + {prepnp(poza,acc); prepncp(poza,acc,int); prepncp(poza,acc,że)}
wykroczyć: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int)}
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)}
wykruszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wykruszać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wykruszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wykruszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wykruszyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wykruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
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)}
wykrystalizować się: _: : perf: subj{cp(int)} + {np(dat)}
wykrystalizować się: _: : perf: subj{cp(że)} + {np(dat)}
wykrystalizować się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wykrystalizować się: _: : perf: subj{np(str)} + {np(dat)}
wykrystalizować: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wykrystalizować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wykrystalizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
wykrztusić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
wykrztusić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wykrztusić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wykrztusić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(żeby)}
wykrztusić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
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)}
wykształcać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wykształcać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wykształcać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wykształcać się: _: : imperf: subj{np(str)} + {xp(locat)}
wykształcać się: _: : imperf: subj{np(str)} + {xp(temp)}
wykształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykształcać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykształcić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wykształcić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wykształcić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wykształcić się: _: : perf: subj{np(str)} + {xp(locat)}
wykształcić się: _: : perf: subj{np(str)} + {xp(temp)}
wykształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykształcić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykuć się: _: : perf: subj{np(str)} + {np(gen)}
wykuć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wykuć się: _: : perf: subj{np(str)} + {xp(locat)}
wykuć: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('na blachę')}
wykuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
wykuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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}
wykurować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wykurować się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wykurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wykurować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
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)}
wykuwać się: _: : imperf: subj{np(str)} + {np(gen)}
wykuwać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wykuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wykuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
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)}
wykwitać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wykwitać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wykwitać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wykwitnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wykwitnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wykwitnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wykwitnąć: _: : perf: subj{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)}
wylec: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(żeby)} + {xp(adl)}
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)}
wylegać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(żeby)} + {xp(adl)}
wylegitymować się: _: : perf: subj{np(str)} + {np(inst)}
wylegitymować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
wylegitymować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
wylęgać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wylęgać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wylęgać: _: : imperf: subj{np(str)} + {xp(adl)}
wylęgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wylęgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
wylogować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wylogować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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łupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
wyłuszczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyłuszczać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyłuszczać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wyłuszczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyłuszczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyłuszczyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyłuszczyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyłuszczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyłysieć: _: : perf: subj{np(str)} + {np(dat)}
wyłysieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyłysieć: _: : perf: subj{np(str)} + {xp(locat)}
wyłysieć: _: : perf: subj{np(str)} + {xp(mod)}
wymacać: _: : perf: subj{np(str)} + {cp(że)}
wymacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wymacać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
wymalować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wymalować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wymalować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wymalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wymamrotać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {or}
wymamrotać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(pod,inst,sg,'nos',natr)}
wymamrotać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
wymamrotać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'nos',natr)} + {or}
wymamrotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
wymamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {preplexnp(pod,inst,sg,'nos',natr)}
wymamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {xp(adl)}
wymamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {preplexnp(pod,inst,sg,'nos',natr)}
wymamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(adl)}
wymamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)} + {preplexnp(pod,inst,sg,'nos',natr)}
wymamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {preplexnp(pod,inst,sg,'nos',natr)}
wymamrotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {preplexnp(pod,inst,sg,'nos',natr)}
wymamrotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,sg,'nos',natr)} + {or}
wymanewrować: _: : perf: subj{np(str)} + {np(inst)}
wymanewrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wymanewrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wymarznąć: _: : perf: subj{np(str)} + {np(dat)}
wymarznąć: _: : perf: subj{np(str)} + {preplexnp(w,loc,sg,'wynik',natr)}
wymarznąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wymarznąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wymarznąć: _: : perf: subj{np(str)} + {prepnp(wskutek,gen)}
wymarznąć: _: : perf: subj{np(str)} + {xp(locat)}
wymarznąć: _: : perf: subj{np(str)} + {xp(temp)}
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)}
wymasować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wymasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymaszerować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wymądrzać się: _: : imperf: subj{np(str)} + {comprepnp(co do)}
wymądrzać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wymądrzać się: _: : imperf: subj{np(str)} + {comprepnp(w kwestii)}
wymądrzać się: _: : imperf: subj{np(str)} + {comprepnp(w sprawie)}
wymądrzać się: _: : imperf: subj{np(str)} + {cp(int)}
wymądrzać się: _: : imperf: subj{np(str)} + {cp(że)}
wymądrzać się: _: : imperf: subj{np(str)} + {or}
wymądrzać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
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)}
wymiatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wymiatać: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wymiatać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wymiatać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
wymierzać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
wymierzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
wymierzać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wymierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wymierzać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
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)}
wymieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wymieść: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wymieść: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wymieść: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wymigać się: _: : perf: subj{np(str)} + {cp(że)}
wymigać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
wymigać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,żeby)}
wymigać się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
wymigać się: _: : perf: subj{np(str)} + {or}
wymigiwać się: _: : imperf: subj{np(str)} + {cp(że)}
wymigiwać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
wymigiwać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,żeby)}
wymigiwać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
wymigiwać się: _: : imperf: subj{np(str)} + {or}
wymijać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wymijać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wymijać się: _: : imperf: subj{np(str)} + {xp(locat)}
wymijać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wymłócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wymłócić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wymłócić: _: : perf: subj{np(str)} + {refl}
wymoczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wymoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wymoczyć: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
wymodelować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wymodelować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wymodelować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
wymodelować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wymodelować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wymodlić 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}
wymodlić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {cp(żeby)}
wymodlić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,inst)} + {cp(żeby)}
wymodlić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {cp(że)}
wymodlić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {cp(żeby)}
wymodlić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)} + {cp(że)}
wymodlić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)} + {cp(żeby)}
wymodlić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(od,gen)}
wymodlić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(u,gen)}
wymodlić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(od,gen)}
wymodlić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
wymodlić: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(od,gen)} + {cp(że)}
wymodlić: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(od,gen)} + {cp(żeby)}
wymodlić: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)} + {cp(że)}
wymodlić: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)} + {cp(żeby)}
wymontować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wymordować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wymordować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymościć się: _: : perf: subj{np(str)} + {xp(locat)}
wymościć: _: : 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)}
wymruczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
wymruczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wymruczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
wymruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wymruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wymruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
wymruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
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}
wymywać się: _: : imperf: subj{np(str)} + {xp(abl)}
wymywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wymywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wymywać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wymywać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
wynajdować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wynajdować: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wynajdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wynaleźć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wynaturzyć się: _: : perf: subj{np(str)}
wynaturzyć: _: : 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)}
wyniszczać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
wyniszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wyniszczyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
wyniszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wyniuchać: _: : perf: subj{np(str)} + {cp(int)}
wyniuchać: _: : perf: subj{np(str)} + {cp(że)}
wyniuchać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyniuchać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wynotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wynotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wynotować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
wynotować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
wynotować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {or}
wynotować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
wynotować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wynotować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {or}
wynudzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
wynudzić się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
wynudzić się: _: : perf: subj{np(str)} + {xp(locat)}
wynudzić: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
wynudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)}
wyobcować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyobcować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyobcować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
wyolbrzymiać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyolbrzymić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wyorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
wyostrzać się: _: : imperf: subj{np(str)} + {np(dat)}
wyostrzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyostrzyć się: _: : perf: subj{np(str)} + {np(dat)}
wyostrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
wypakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wypakowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
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)}
wypaplać się: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
wypaplać się: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wypaplać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
wypaplać się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
wypaplać: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
wypaplać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wypaplać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
wypaplać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypaplać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wypaplać: _: : perf: subj{np(str)} + {or}
wypaplać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {xp(locat)}
wyparować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyparować: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
wyparować: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,gen)}
wyparować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)} + {xp(mod)}
wyparowywać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyparowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyparowywać: _: : imperf: subj{np(str)} + {xp(abl)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
wyparowywać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(perl)}
wyparzać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyparzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyparzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wyparzyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyparzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wypasać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wypasać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wypasać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wypasać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wypasać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
wypasać: _: : imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
wyperswadować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
wyperswadować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
wyperswadować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
wyperswadować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
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ąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wypiąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wypiąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wypiąć się: _: : perf: subj{np(str)} + {xp(adl)}
wypiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wypiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wypiąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypiąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
wypiec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypiekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypielęgnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wypielęgnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wypielęgnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
wypieścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypięknieć: _: : perf: subj{np(str)} + {advp(misc)}
wypięknieć: _: : perf: subj{np(str)} + {np(dat)}
wypięknieć: _: : perf: subj{np(str)} + {np(inst)}
wypięknieć: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
wypięknieć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wypięknieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wypięknieć: _: : perf: subj{np(str)} + {xp(locat)}
wypięknieć: _: : perf: subj{np(str)} + {xp(mod)}
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)}
wypinać się: _: : imperf: subj{np(str)} + {np(dat)}
wypinać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wypinać się: _: : imperf: subj{np(str)} + {xp(adl)}
wypinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wypinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypinać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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}
wyplatać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
wyplenić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyplenić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wypleść: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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łaszać się: _: : imperf: subj{np(str)} + {xp(abl)}
wypłaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypłaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypłoszyć się: _: : perf: subj{np(str)} + {xp(abl)}
wypłoszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypłoszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypłowieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
wypłowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wypłowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wypłowieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
wypłowieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wypłukać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wypłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypłukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wypłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
wypłukać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wypłukać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wypłukiwać się: _: : imperf: subj{np(str)} + {prepnp(pod,inst)}
wypłukiwać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wypłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
wypłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wypłukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wypocić się: _: : perf: subj{np(str)} + {xp(locat)}
wypocić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
wypogodzić się: _: : perf: subj{E} + {xp(locat)}
wypogodzić się: _: : perf: subj{np(str)} + {np(dat)}
wypogodzić: _: : perf: 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)}
wypompować się: _: : perf: subj{np(str)}
wypompować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypompowywać się: _: : imperf: subj{np(str)}
wypompowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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}
wypośrodkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
wypośrodkować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
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)}
wyprać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyprać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wyprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyprać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wyprać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
wyprawiać się: _: : imperf: subj{nonch} + {xp(locat)}
wyprawiać się: _: : imperf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
wyprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyprawić się: _: : perf: subj{np(str)} + {np(inst); prepnp(na,loc); prepnp(w,loc)} + {xp(abl)} + {xp(adl)}
wyprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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)}
wypromieniować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypromieniowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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}
wypróżniać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wypróżniać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wypróżniać się: _: : imperf: subj{np(str)} + {xp(adl)}
wypróżniać się: _: : imperf: subj{np(str)} + {xp(locat)}
wypróżniać się: _: : imperf: subj{np(str)} + {xp(temp)}
wypróżniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypróżniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wypróżniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wypróżniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
wypróżniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
wypróżnić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wypróżnić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wypróżnić się: _: : perf: subj{np(str)} + {xp(abl)}
wypróżnić się: _: : perf: subj{np(str)} + {xp(adl)}
wypróżnić się: _: : perf: subj{np(str)} + {xp(locat)}
wypróżnić się: _: : perf: subj{np(str)} + {xp(perl)}
wypróżnić się: _: : perf: subj{np(str)} + {xp(temp)}
wypróżnić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypróżnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wypróżnić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wypruć się: _: : perf: subj{np(str)} + {cp(żeby)}
wypruć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wypruć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wypruć się: _: : perf: subj{np(str)} + {xp(abl)}
wypruć: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruć: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruć: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(str,pl,'flak',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruć: _: : perf: subj{np(str)} + {cp(żeby)} + {lexnp(str,pl,'żyła',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wypruć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,pl,'flak',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruć: _: : perf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,pl,'żyła',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruć: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruć: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruć: _: : perf: subj{np(str)} + {prepnp(za,acc)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruć: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruć: _: : perf: subj{np(str)} + {xp(locat)} + {lexnp(dat,sg,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruwać się: _: : imperf: subj{np(str)} + {cp(żeby)}
wypruwać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wypruwać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wypruwać się: _: : imperf: subj{np(str)} + {xp(abl)}
wypruwać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruwać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruwać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(str,pl,'flak',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruwać: _: : imperf: subj{np(str)} + {cp(żeby)} + {lexnp(str,pl,'żyła',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,pl,'flak',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,pl,'żyła',natr)} + {preplexnp(z,gen,_,'siebie',natr)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruwać: _: : imperf: subj{np(str)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wypruwać: _: : imperf: subj{np(str)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'flak',natr)}
wypruwać: _: : imperf: subj{np(str)} + {xp(locat)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'żyła',natr)}
wyprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyprzątnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
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)}
wyprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprzęgnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wypucować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wypucować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypucować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wypucować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
wypytać się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(co do)}
wypytać się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(na temat)}
wypytać się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(w kwestii)}
wypytać się: _: : perf: subj{np(str)} + {np(gen)} + {comprepnp(w sprawie)}
wypytać się: _: : perf: subj{np(str)} + {np(gen)} + {or}
wypytać się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
wypytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
wypytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
wypytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
wypytać: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
wypytać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wypytać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
wypytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {comprepnp(co do)}
wypytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {comprepnp(na temat)}
wypytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {comprepnp(w kwestii)}
wypytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {comprepnp(w sprawie)}
wypytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {or}
wypytywać się: _: : imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
wypytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
wypytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
wypytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
wypytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
wypytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
wypytywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
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)}
wyratować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
wyratować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyratować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
wyratować się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyratować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
wyratować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
wyratować: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
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}
wyremontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyremontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyremontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyremontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
wyremontować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(za,acc)}
wyremontować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
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)}
wyroić się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyroić się: _: : perf: subj{np(str)} + {xp(locat)}
wyroić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
wyrolować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
wyrozumieć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że)} + {prepnp(z,gen)}
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)}
wyrysować się: _: : perf: subj{np(str)} + {xp(locat)}
wyrysować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)} + {xp(locat)}
wyrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wyrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wyrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wyrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wyrysować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
wyrysować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(mod)}
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)}
wyrzezać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wyrzezać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyrzezać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyrzezać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
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}
wyrzygać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wyrzygać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyrzygać się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
wyrzygać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyrzygać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
wysadzać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wysadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'powietrze',natr)}
wysadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wysadzać: _: : imperf: subj{np(str)} + {preplexnp(w,acc,sg,'powietrze',natr)} + {refl}
wysadzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wysadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'powietrze',natr)}
wysadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysadzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wysadzić: _: : perf: subj{np(str)} + {preplexnp(w,acc,sg,'powietrze',natr)} + {refl}
wysapać się: _: : perf: subj{np(str)}
wysapać: _: : perf: subj{np(str)} + {cp(int)}
wysapać: _: : perf: subj{np(str)} + {cp(że)}
wysapać: _: : perf: subj{np(str)} + {cp(żeby)}
wysapać: _: : perf: subj{np(str)} + {np(str)}
wysapać: _: : perf: subj{np(str)} + {or}
wysączyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysączyć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)} + {or}
wysączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wysączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wysączyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
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)}
wysforować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wysforować się: _: : perf: subj{np(str)} + {prepnp(przed,acc)}
wysforować się: _: : perf: subj{np(str)} + {xp(adl)}
wysiać się: _: : perf: subj{np(str)} + {xp(adl)}
wysiać się: _: : perf: subj{np(str)} + {xp(locat)}
wysiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wysiewać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
wysiewać się: _: : imperf: subj{np(str)} + {xp(locat)}
wysiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wysiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wysikać się: _: : perf: subj{np(str)} + {xp(adl)}
wysikać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysilać się: _: : imperf: subj{np(str)} + {cp(żeby)}
wysilać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wysilać: _: : imperf: subj{np(str)} + {np(str)}
wysilić się: _: : perf: subj{np(str)} + {cp(żeby)}
wysilić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wysilić: _: : perf: subj{np(str)} + {np(str)}
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)}
wyskalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyskalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyskalować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
wyskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyskrobać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wyskrobać: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyskrobać: _: : 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)}
wyskrobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
wyskrobać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wyskrobać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {or}
wyskrobać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wyskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
wyskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wyskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wyskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wyskrobać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wyskrobać: _: : 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)}
wyskubać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wysłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wysłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {xp(adl)}
wysławiać się: _: : imperf: subj{np(str)} + {np(inst)}
wysławiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wysławiać się: _: : imperf: subj{np(str)} + {xp(mod)}
wysławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
wysławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wysławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'niebiosa',natr)}
wysławiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wysłowić się: _: : perf: subj{np(str)} + {np(inst)}
wysłowić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wysłowić się: _: : perf: subj{np(str)} + {xp(mod)}
wysłowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
wysmarkać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wysmarkać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wysmarować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wysmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysmażyć się: _: : perf: subj{np(str)} + {advp(misc)}
wysmażyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wysmażyć się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wysmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
wysmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wysmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wysmażyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wysnuć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wysnuć się: _: : perf: subj{np(str)} + {xp(abl)}
wysnuć: _: : perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wysnuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wysnuwać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wysnuwać się: _: : imperf: subj{np(str)} + {xp(abl)}
wysnuwać: _: : imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wysnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wysondować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(int)}
wysondować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(że)}
wysondować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(u,gen)}
wysondować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysondować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {comprepnp(co do)}
wysondować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(int)}
wysondować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
wysondować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
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)}
wyspecyfikować: _: : perf: subj{np(str)} + obj{cp(int)}
wyspecyfikować: _: : perf: subj{np(str)} + obj{cp(że)}
wyspecyfikować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
wysprzątać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysprzątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wysprzątać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysprzątać: _: : perf: subj{np(str)} + {xp(locat)}
wysprzedać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wysprzedać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wysprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wysprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysprzedawać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'cena',atr)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,acc)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(po,loc)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {xp(adl)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(adl)}
wysprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {preplexnp(w,loc,_,'cena',atr)}
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)}
wystać się: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
wystać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wystać: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
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)}
wysterylizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysterylizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wysterylizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wysterylizować: _: : perf: subj{np(str)} + {refl}
wystękać się: _: : perf: subj{np(str)}
wystękać: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
wystękać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wystękać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wystękać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wystękać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
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)}
wystroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wystroić: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
wystrychnąć: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'dudek',atr)}
wystrychnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wystrychnąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wystrzegać się: _: : imperf: subj{np(str)} + {cp(żeby)}
wystrzegać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
wystrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wystrzelać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wystrzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(co do,gen)}
wystrzelać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wystrzelać: _: : imperf: subj{np(str)} + {or}
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)}
wystrzeliwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
wystrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wystrzeliwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wystrzeliwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wystrzeliwać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
wystrzępić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wystrzępić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wystrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wystrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wystrzępić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
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)}
wystudzić się: _: : perf: subj{np(str)}
wystudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wystukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wystukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wystukać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wystukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wystukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wystukiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
wystygnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wystylizować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wystylizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wysublimować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wysublimować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wysublimować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wysublimować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wysublimować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wysublimować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wysublimować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysublimować: _: : perf: subj{np(str)} + {xp(adl)}
wysublimować: _: : perf: subj{np(str)} + {xp(locat)}
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)}
wysupłać się: _: : perf: subj{np(str)} + {xp(abl)}
wysupłać: _: : perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)} + {xp(abl)}
wysupłać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
wysupływać się: _: : imperf: subj{np(str)} + {xp(abl)}
wysupływać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wysuszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wysuszać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wysuszać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wysuszać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
wysuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wysuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wysuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wysuszyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wysuszyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wysuszyć się: _: : perf: subj{np(str)} + {xp(locat)}
wysuszyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wysuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wysuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wysuszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
wyswatać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyswatać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wyswobadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyswobadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(spod,gen)}
wyswobadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyswobadzać: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wyswobadzać: _: : imperf: subj{np(str)} + {prepnp(spod,gen)} + {refl}
wyswobadzać: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wyswobodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyswobodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(spod,gen)}
wyswobodzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyswobodzić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wyswobodzić: _: : perf: subj{np(str)} + {prepnp(spod,gen)} + {refl}
wyswobodzić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wysychać: _: : imperf: {np(dat)} + {xp(locat)}
wysychać: _: : imperf: subj{np(str)} + {np(dat)}
wysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
wysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
wysyłać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
wysypiać się: _: : imperf: subj{np(str)}
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)}
wyszacować: _: : perf: subj{np(str)} + {cp(int)}
wyszacować: _: : perf: subj{np(str)} + {cp(że)}
wyszacować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
wyszacować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyszacować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyszaleć: _: : perf: subj{np(str)}
wyszarpać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyszarpać się: _: : perf: subj{np(str)} + {xp(abl)}
wyszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyszarpać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wyszarpnąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyszarpnąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(abl)}
wyszarpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyszarpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyszarpnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyszarpywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyszarpywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyszarpywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyszarpywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyszarpywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wyszczególniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyszczególniać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyszczególniać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
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)}
wyszczerzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wyszczerzyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wyszczerzyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
wyszczerzyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
wyszczotkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wyszczotkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(mod)}
wyszczuplać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
wyszlifować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyszorować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wyszorować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyszperać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyszpiegować: _: : perf: subj{np(str)} + {cp(int)}
wyszpiegować: _: : perf: subj{np(str)} + {cp(że)}
wyszpiegować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
wyszumieć się: _: : perf: subj{np(str)}
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)}
wyszydzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
wyszydzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
wyszydzać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyszydzać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
wyszydzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyszydzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
wyszydzić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wyszydzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wyszydzić: _: : perf: subj{np(str)} + obj{np(str)} + {or}
wyszydzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wyszykować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyszykować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyszykować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
wyszykować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
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ścielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyścielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyściełać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyściskać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
wyściskać: _: : perf: subj{np(str)} + obj{np(str)}
wyśledzić: _: : perf: subj{np(str)} + {cp(int)}
wyśledzić: _: : perf: subj{np(str)} + {cp(że)}
wyśledzić: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
wyślizgać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyślizgać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyślizgać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyślizgiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyślizgiwać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wyślizgiwać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wyślizgiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyślizgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyślizgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(perl)}
wyślizgnąć się: _: : perf: subj{np(str)} + {xp(adl)}
wyśliznąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyśliznąć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyśliznąć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyśliznąć: _: : perf: 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śnić się: _: : perf: subj{cp(że)} + {np(dat)}
wyśnić się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
wyśnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyśnić: _: : perf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,int); 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śrubować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyświadczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyświadczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyświecić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wyświecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyświecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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)}
wytapiać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wytapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytargać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(abl)} + {xp(adl)}
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)}
wytarzać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wytarzać się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wytarzać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wytarzać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wytaszczyć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wytaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wytężać się: _: : imperf: subj{np(str)} + {cp(żeby)}
wytężać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wytężać się: _: : imperf: subj{np(str)} + {xp(adl)}
wytężać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wytężać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wytężać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wytężyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wytężyć się: _: : perf: subj{np(str)} + {xp(adl)}
wytężyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wytężyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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łaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wytłaczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytłoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wytłoczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytłuc się: _: : perf: subj{np(str)} + {np(dat)}
wytłuc: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {or}
wytłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
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)}
wytłumić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wytłuścić się: _: : perf: subj{np(str)} + {np(dat)}
wytłuścić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
wytłuścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
wytopić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wytopić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytracać: _: : imperf: subj{np(str)} + obj{np(str)}
wytracić: _: : perf: subj{np(str)} + obj{np(str)}
wytransferować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytransferować: _: : 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)}
wytrenować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
wytrenować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wytrenować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wytrenować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wytresować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
wytresować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wytresować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wytresować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
wytruć się: _: : perf: subj{np(str)} + {np(inst)}
wytruć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wytrwać: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {xp(dur)}
wytrwać: _: : perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
wytryskać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wytryskać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytryskiwać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wytryskiwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytrysnąć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wytrysnąć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytrzasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
wytrzebić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wytrzebić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wytrzebić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
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}
wytrzepać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytrzeszczać się: _: : imperf: subj{np(str)}
wytrzeszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wytrzeszczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wytrzeszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
wytrzeszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wytrzeszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wytrzeszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wytrzeszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytrzeszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
wyuczyć 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)}
wyuczyć się: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
wyuczyć się: _: : perf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
wyuczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wyuczyć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
wyuczyć: _: : 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)}
wyuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
wyuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyuczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
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ąchać: _: : perf: subj{np(str)} + {cp(int)}
wywąchać: _: : perf: subj{np(str)} + {cp(że)}
wywąchać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
wywdzięczać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {cp(że)}
wywdzięczać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wywdzięczać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
wywdzięczać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wywdzięczyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {cp(że)}
wywdzięczyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wywdzięczyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
wywdzięczyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wywędrować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wywiać: _: : perf: {np(str)} + {xp(abl)} + {xp(adl)}
wywiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wywiadywać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(od,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(u,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(z,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(od,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(u,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(co do)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(na temat)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(u,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {comprepnp(co do)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {comprepnp(na temat)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(int)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {comprepnp(co do)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {comprepnp(na temat)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wywiadywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wywiadywać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
wywiedzieć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(od,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(u,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(z,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(od,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(u,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(co do)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(na temat)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(u,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {comprepnp(co do)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {comprepnp(na temat)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(int)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {comprepnp(co do)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {comprepnp(na temat)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wywiedzieć się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(ż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)}
wywietrzeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wywietrzyć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wywietrzyć się: _: : perf: subj{np(str)} + {xp(locat)}
wywietrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wywietrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywietrzyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wywietrzyć: _: : perf: subj{np(str)} + obj{xp(locat)}
wywietrzyć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wywiewać: _: : imperf: {np(str)} + {xp(abl)} + {xp(adl)}
wywiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
wywijać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
wywijać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
wywijać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wywijać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wywijać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wywijać się: _: : imperf: subj{np(str)} + {xp(abl)}
wywijać: _: : imperf: subj{np(str)} + {np(inst)}
wywijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wywijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywijać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywinąć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
wywinąć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
wywinąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wywinąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wywinąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wywinąć się: _: : perf: subj{np(str)} + {xp(abl)}
wywinąć: _: : perf: subj{np(str)} + {np(inst)}
wywinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wywinąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywinąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywindować się: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)}
wywindować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wywindować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wywindować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {xp(abl)} + {xp(adl)}
wywindować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wywlec się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wywlec się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wywlec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wywlec: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wywlekać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wywlekać się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wywlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wywlekać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wywłaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywłaszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywnętrzać się: _: : imperf: subj{np(str)} + {comprepnp(na temat)}
wywnętrzać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wywnętrzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnętrzać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wywnętrzać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
wywnętrzać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wywnętrzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wywnętrzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnętrzać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
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)}
wywojować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wywojować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wywojować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wywojować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wywróżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {cp(int)}
wywróżyć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {cp(że)}
wywróżyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(z,gen)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wywrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wywrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wywrzaskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wywrzaskiwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
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)}
wyzbierać się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
wyzbierać się: _: : perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wyzbierać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {xp(adl)}
wyzbierać się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)} + {xp(adl)}
wyzbierać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wyzbyć się: _: : perf: subj{np(str)} + {np(gen)}
wyzbywać się: _: : imperf: subj{np(str)} + {np(gen)}
wyzdrowieć: _: : perf: subj{np(str)} + {prepnp(po,loc)}
wyzdrowieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wyzdychać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
wyzdychać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wyzdychać: _: : 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)}
wyzionąć: _: : perf: subj{np(str)} + {lexnp(str,sg,'duch',natr)}
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)}
wyzuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyzuć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
wyzyskać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyzyskać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyzyskać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
wyzyskiwać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyzyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyzyskiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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żalać się: _: : imperf: subj{np(str)} + {cp(że)} + {xp(locat)}
wyżalać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyżalać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyżalać się: _: : imperf: subj{np(str)} + {np(dat)} + {or}
wyżalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wyżalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyżalać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wyżalać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
wyżalać się: _: : imperf: subj{np(str)} + {xp(locat)} + {or}
wyżalić się: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyżalić się: _: : perf: subj{np(str)} + {np(dat)} + {or}
wyżalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
wyżalić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wyżalić się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
wyżalić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
wyżalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
wyżalić się: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
wyżąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyżąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(adl)}
wyżąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
wyżebrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(od,gen)}
wyżebrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(u,gen)}
wyżebrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(że)}
wyżebrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(żeby)}
wyżebrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(że)}
wyżebrać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(żeby)}
wyżebrać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst)} + {prepnp(od,gen)}
wyżebrać: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst)} + {prepnp(u,gen)}
wyżerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyżerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyżerać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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żreć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyżreć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyżreć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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żymać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyżymać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(adl)}
wyżymać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
wzbierać: _: : imperf: subj{np(str)} + {advp(misc)}
wzbierać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
wzbierać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
wzbierać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wzbierać: _: : imperf: subj{np(str)} + {xp(locat)} + {xp(mod)}
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)}
wzbraniać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
wzbraniać się: _: : imperf: subj{np(str)} + {np(inst)} + {cp(że)}
wzbraniać się: _: : imperf: subj{np(str)} + {np(inst)} + {or}
wzbraniać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wzbraniać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
wzbraniać: _: : imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
wzbraniać: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen)}
wzbronić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
wzbronić się: _: : perf: subj{np(str)} + {cp(że)}
wzbronić się: _: : perf: subj{np(str)} + {or}
wzbronić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wzbronić się: _: : perf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
wzbronić: _: : perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
wzbronić: _: : perf: subj{np(str)} + {np(dat)} + {np(gen)}
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)}
wzdragać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
wzdragać się: _: : imperf: subj{np(str)} + {cp(że)}
wzdragać się: _: : imperf: subj{np(str)} + {or}
wzdragać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wzdragać się: _: : imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
wzdragać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
wzdrygać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
wzdrygać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
wzdrygać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
wzdrygać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
wzdrygać: _: : imperf: subj{np(str)} + {np(inst)}
wzdrygnąć się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
wzdrygnąć: _: : perf: subj{np(str)} + {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)}
wzejść: _: : perf: subj{np(str)} + {np(dat)}
wzejść: _: : perf: subj{np(str)} + {prepnp(dla,gen)}
wzejść: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
wzejść: _: : perf: subj{np(str)} + {prepnp(na,loc)}
wzejść: _: : perf: subj{np(str)} + {prepnp(od,gen)}
wzejść: _: : perf: subj{np(str)} + {prepnp(z,gen)}
wzejść: _: : perf: subj{np(str)} + {xp(mod)}
wzgardzić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
wzlatywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wzlatywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wzlatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,inst)}
wzlatywać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
wzlecieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wzlecieć: _: : perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wzlecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,inst)}
wzlecieć: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
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)}
wzniecać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
wzniecać się: _: : imperf: subj{np(str)} + {xp(locat)}
wzniecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
wzniecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wzniecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
wzniecać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
wzniecić się: _: : perf: subj{np(str)}
wzniecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
wzniecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wzniecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
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)}
wżerać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
wżerać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wżerać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wżyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
wżywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
wżywać się: _: : imperf: subj{np(str)} + {xp(adl)}
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)}
zaadoptować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
zaanonsować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zaanonsować: _: : perf: subj{np(str)} + {np(dat)} + {refl}
zaanonsować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
zaanonsować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaanonsować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zaanonsować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zaanonsować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaanonsować: _: : perf: subj{np(str)} + {or} + {refl}
zaanonsować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
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)}
zaaprobować: _: : perf: subj{np(str)} + {cp(int)}
zaaprobować: _: : perf: subj{np(str)} + {cp(że)}
zaaprobować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
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)}
zaaresztować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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}
zabagnić się: _: : perf: subj{np(str)}
zabagnić: _: : perf: subj{np(str)} + {np(str)}
zabalsamować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zabalsamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabałaganić się: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zabałaganić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zabałaganić: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zabałaganić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabałaganić: _: : perf: subj{np(str)} + {refl}
zabandażować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zabandażować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabarwiać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
zabarwiać się: _: : imperf: subj{np(str)} + {np(inst)}
zabarwiać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zabarwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabarwić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zabarwić się: _: : perf: subj{np(str)} + {np(inst)}
zabarwić: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zabarwić: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
zabawiać się: _: : imperf: subj{np(str)} + {np(inst)}
zabawiać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zabawiać się: _: : imperf: subj{np(str)} + {xp(mod)}
zabawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabawiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
zabazgrać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabełkotać się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zabełkotać: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(pod,inst,_,'nos',natr)}
zabełkotać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',atr)}
zabełkotać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',atr)} + {or}
zabełkotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',atr)}
zabełkotać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'nos',natr)}
zabełkotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zabełkotać: _: : perf: subj{np(str)} + {prepadjp(po,postp)}
zabełkotać: _: : perf: subj{np(str)} + {preplexnp(pod,inst,_,'nos',natr)} + {or}
zabełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)} + {nonch}
zabełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zabełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zabełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zabełkotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
zabetonować się: _: : perf: subj{np(str)} + {xp(locat)}
zabetonować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabetonować: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
zabębnić: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
zabębnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(w,acc,sg,'ucho',natr)}
zabębnić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,sg,'ucho',natr)}
zabębnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zabębnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
zabębnić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zabębnić: _: : 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)}
zabębnić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zabębnić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
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)}
zabielić się: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zabielić się: _: : perf: subj{np(str)} + {np(inst)}
zabielić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zabielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabierać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zabierać się: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
zabierać się: _: : imperf: subj{np(str)} + {xp(adl)}
zabierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zabierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zabierać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zabierać: _: : imperf: subj{np(str)} + obj{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)}
zabliźniać się: _: : imperf: subj{np(str)}
zabliźniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabliźnić się: _: : perf: subj{np(str)}
zabliźnić: _: : perf: subj{np(str)} + obj{np(str)} + {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łąkać się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zabłąkać się: _: : perf: subj{np(str)} + {xp(locat)}
zabłocić się: _: : perf: subj{np(str)} + {np(dat)}
zabłocić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabłysnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zabłysnąć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaboleć: _: : perf: {np(str)} + {comprepnp(z powodu)} + {xp(locat)}
zaboleć: _: : perf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
zaboleć: _: : perf: {np(str)} + {prepnp(z,gen)} + {xp(locat)}
zaboleć: _: : perf: subj{cp(gdy)} + {np(str)}
zaboleć: _: : perf: subj{cp(int)} + {np(str)}
zaboleć: _: : perf: subj{cp(jak)} + {np(str)}
zaboleć: _: : perf: subj{cp(jeśli)} + {np(str)}
zaboleć: _: : perf: subj{cp(kiedy)} + {np(str)}
zaboleć: _: : perf: subj{cp(że)} + {np(str)}
zaboleć: _: : 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)}
zaboleć: _: : perf: subj{np(str)} + {np(str)} + {comprepnp(z powodu)}
zaboleć: _: : perf: subj{np(str)} + {np(str)} + {cp(że)}
zaboleć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
zaboleć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
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)}
zabrnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zabrnąć: _: : perf: subj{np(str)} + {xp(adl)}
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)}
zabrzęczeć: _: : perf: {np(dat)} + {xp(locat)}
zabrzęczeć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zabrzęczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zabudować się: _: : perf: subj{np(str)} + {np(inst)}
zabudować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabudowywać się: _: : imperf: subj{np(str)} + {np(inst)}
zabudowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabulgotać się: _: : perf: subj{np(str)} + {cp(że)}
zabulgotać się: _: : perf: subj{np(str)} + {np(inst)}
zabulgotać się: _: : perf: subj{np(str)} + {or}
zabulgotać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zabulgotać: _: : perf: {np(dat)} + {xp(locat)}
zabulgotać: _: : perf: subj{cp(że)} + {xp(locat)}
zabulgotać: _: : perf: subj{np(str)} + {cp(że)}
zabulgotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zabulgotać: _: : perf: subj{np(str)} + {np(inst)}
zabulgotać: _: : perf: subj{np(str)} + {or}
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}
zaburzać się: _: : imperf: subj{np(str)} + {np(dat)}
zaburzać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
zaburzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaburzyć się: _: : perf: subj{np(str)} + {np(dat)}
zaburzyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
zaburzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zacentrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
zacentrować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zacerować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zacharczeć: _: : perf: subj{np(str)} + {cp(że)}
zacharczeć: _: : perf: subj{np(str)} + {or}
zacharczeć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
zachichotać się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zachichotać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
zachichotać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
zachichotać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zachichotać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
zachichotać: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zachlapać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zachlapać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zachlapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zachlapać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zachlapać: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
zachmurzyć się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zachmurzyć się: _: : perf: subj{np(str)} + {cp(int)}
zachmurzyć się: _: : perf: subj{np(str)} + {cp(że)}
zachmurzyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachmurzyć się: _: : perf: subj{np(str)} + {or}
zachmurzyć: _: : perf: subj{np(str)} + {np(str)}
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}
zachrapać się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zachrapać: _: : perf: subj{np(str)} + {or}
zachrapać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zachrapać: _: : perf: subj{np(str)} + {xp(mod)}
zachrobotać: _: : perf: {np(dat)} + {xp(temp)}
zachrobotać: _: : perf: {prepadjp(po,postp)} + {or}
zachrobotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zachrobotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(temp)}
zachrobotać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zachrobotać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zachrobotać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
zachrobotać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zachrobotać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zachrobotać: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
zachrobotać: _: : perf: {xp(locat)}
zachrypieć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zachrypieć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {or}
zachrypnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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)}
zachwaścić się: _: : perf: {np(inst)} + {xp(locat)}
zachwaścić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zachwaścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zachybotać się: _: : perf: subj{np(str)}
zachybotać: _: : perf: subj{np(str)} + {np(inst)}
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)}
zaciec: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaciec: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaciec: _: : perf: {xp(locat)}
zaciekać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zaciekać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaciekać: _: : imperf: {xp(locat)}
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)}
zacietrzewiać się: _: : imperf: subj{np(str)} + {cp(że)}
zacietrzewiać się: _: : imperf: subj{np(str)} + {or}
zacietrzewiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zacietrzewić się: _: : perf: subj{np(str)} + {cp(że)}
zacietrzewić się: _: : perf: subj{np(str)} + {or}
zacietrzewić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
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)}
zacumować: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zacumować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zacumować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zaczadzić się: _: : perf: subj{np(str)} + {xp(locat)}
zaczadzić: _: : perf: subj{np(str)} + obj{np(str)}
zaczadzieć: _: : perf: subj{np(str)} + {np(inst)}
zaczadzieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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)}
zaczarować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zaczarować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zaczarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaczarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaczarować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
zaczesać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {refl}
zaczesać: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)} + {xp(adl)}
zaczesać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zaczesywać: _: : imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
zaczesywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zaczesywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(mod)}
zaczesywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {xp(mod)}
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)}
zaczytać się: _: : perf: subj{np(str)} + {np(inst)}
zaczytać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaczytać: _: : perf: subj{np(str)} + obj{np(str)}
zaczytywać się: _: : imperf: subj{np(str)} + {np(inst)}
zaczytywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zaczytywać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
zadatkować: _: : _: subj{np(str)} + obj{np(str)} + {np(dat)}
zadatkować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zadatkować: _: : _: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zadekować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zadekować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
zadenuncjować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
zadenuncjować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)} + {refl}
zadenuncjować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {np(dat)} + {or} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zadenuncjować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(do,gen)}
zadenuncjować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {or}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {or}
zadenuncjować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zadenuncjować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {or} + {refl}
zadenuncjować: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
zadeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zadeptywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zadławić się: _: : perf: subj{np(str)} + {np(inst)}
zadławić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zadławić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zadławić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadłużać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)}
zadłużać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)} + {refl}
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}
zadołować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zadołować: _: : perf: subj{np(str)} + {xp(locat)} + {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)}
zadośćuczynić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(za,acc)}
zadośćuczynić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
zadrapać: _: : perf: {np(str)} + {xp(locat)}
zadrapać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zadrapać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zadrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zadrapać: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
zadrasnąć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zadrasnąć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zadrasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadrasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zadrasnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zadręczać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
zadręczać: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zadręczać: _: : imperf: subj{np(str)} + {np(str)} + {cp(że)}
zadręczać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zadręczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zadręczać: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {refl}
zadręczyć: _: : perf: subj{np(str)} + {cp(że)} + {refl}
zadręczyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zadręczyć: _: : perf: subj{np(str)} + {np(str)} + {cp(że)}
zadręczyć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zadręczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zadręczyć: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {refl}
zadrgać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zadrgać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zadrgać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zadrgać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadrgać: _: : perf: subj{np(str)} + {np(inst)}
zadrukować: _: : 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)}
zadurzyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zadusić się: _: : perf: subj{np(str)} + {np(inst)}
zadusić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zadusić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zadusić się: _: : perf: subj{np(str)} + {xp(locat)}
zadusić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zadusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zadusić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zadygotać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zadygotać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zadygotać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zadygotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadygotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)} + {preplexnp(na,acc,sg,'myśl',ratr)}
zadygotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)} + {preplexnp(na,acc,sg,'widok',ratr)}
zadygotać: _: : perf: subj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'myśl',ratr)}
zadygotać: _: : perf: subj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'widok',ratr)}
zadymić się: _: : perf: subj{np(str)} + {np(inst)}
zadymić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadysponować: _: : perf: subj{np(str)} + {cp(int)}
zadysponować: _: : perf: subj{np(str)} + {cp(że)}
zadysponować: _: : perf: subj{np(str)} + {cp(żeby)}
zadysponować: _: : perf: subj{np(str)} + {np(inst)}
zadysponować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zadysponować: _: : perf: subj{np(str)} + {or}
zadyszeć się: _: : perf: subj{np(str)} + {np(inst)}
zadyszeć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zadyszeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zadyszeć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zadyszeć: _: : perf: subj{np(str)}
zadziać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadziać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zadzierzgnąć się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
zadzierzgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zadziwiać się: _: : imperf: subj{np(str)} + {cp(int)}
zadziwiać się: _: : imperf: subj{np(str)} + {cp(że)}
zadziwiać się: _: : imperf: subj{np(str)} + {np(dat)}
zadziwiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zadziwiać się: _: : imperf: subj{np(str)} + {or}
zadziwiać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zadziwiać: _: : imperf: subj{cp(gdy)} + {np(str)}
zadziwiać: _: : imperf: subj{cp(int)} + {np(str)}
zadziwiać: _: : imperf: subj{cp(jak)} + {np(str)}
zadziwiać: _: : imperf: subj{cp(jeśli)} + {np(str)}
zadziwiać: _: : imperf: subj{cp(kiedy)} + {np(str)}
zadziwiać: _: : imperf: subj{cp(że)} + {np(str)}
zadziwiać: _: : 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)}
zadziwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
zadziwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zadziwiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zadziwić się: _: : perf: subj{np(str)} + {cp(int)}
zadziwić się: _: : perf: subj{np(str)} + {cp(że)}
zadziwić się: _: : perf: subj{np(str)} + {np(dat)}
zadziwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zadziwić się: _: : perf: subj{np(str)} + {or}
zadziwić się: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zadziwić: _: : perf: subj{cp(gdy)} + {np(str)}
zadziwić: _: : perf: subj{cp(int)} + {np(str)}
zadziwić: _: : perf: subj{cp(jak)} + {np(str)}
zadziwić: _: : perf: subj{cp(jeśli)} + {np(str)}
zadziwić: _: : perf: subj{cp(kiedy)} + {np(str)}
zadziwić: _: : perf: subj{cp(że)} + {np(str)}
zadziwić: _: : 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)}
zadziwić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zadziwić: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zadziwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
zadźwięczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zadźwięczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadźwięczeć: _: : perf: subj{np(str)} + {or}
zadźwięczeć: _: : perf: subj{or} + {np(dat)} + {xp(locat)}
zafajdać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zafajdać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zafajdać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zafajdać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zafalować: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zafalować: _: : perf: subj{np(str)} + {np(dat)} + {xp(mod)}
zafalować: _: : perf: subj{np(str)} + {np(inst)}
zafalować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
zafalować: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zafalować: _: : perf: subj{np(str)} + {xp(adl)}
zafałszować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zafarbować się: _: : perf: subj{np(str)} + {advp(misc)}
zafarbować się: _: : perf: subj{np(str)} + {np(inst)}
zafarbować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zafarbować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zafarbować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zafarbować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
zafoliować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zafoliować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zafoliować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zafrapować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zafrapować: _: : perf: subj{cp(int)} + {np(str)}
zafrapować: _: : perf: subj{cp(że)} + {np(str)}
zafrapować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zafrapować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zafrasować się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zafrasować się: _: : perf: subj{np(str)} + {cp(int)}
zafrasować się: _: : perf: subj{np(str)} + {cp(że)}
zafrasować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zafrasować się: _: : perf: subj{np(str)} + {or}
zafrasować się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zafrasować: _: : perf: subj{cp(gdy)} + {np(str)}
zafrasować: _: : perf: subj{cp(int)} + {np(str)}
zafrasować: _: : perf: subj{cp(jak)} + {np(str)}
zafrasować: _: : perf: subj{cp(jeśli)} + {np(str)}
zafrasować: _: : perf: subj{cp(kiedy)} + {np(str)}
zafrasować: _: : perf: subj{cp(że)} + {np(str)}
zafrasować: _: : 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)}
zafrasować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
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}
zagalopować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zagalopować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zaganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zaganiać: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
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)}
zagasić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zagasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zagasić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagasić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zagasnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zagasnąć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zagasnąć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
zagipsować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
zaglądnąć: _: : perf: subj{np(str)} + {cp(int)}
zaglądnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
zaglądnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaglądnąć: _: : perf: 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łodzić: _: : perf: subj{np(str)} + obj{np(str)}
zagłodzić: _: : perf: subj{np(str)} + {refl}
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)}
zagmatwać się: _: : perf: subj{np(str)} + {np(dat)}
zagmatwać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zagmatwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zagnać się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zagnać się: _: : perf: subj{np(str)} + {xp(adl)}
zagnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zagnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zagnać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zagnieść się: _: : perf: subj{np(str)}
zagnieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zagoić się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
zagoić się: _: : perf: subj{np(str)} + controller{prepnp(na,loc)} + controllee{xp(mod)}
zagoić: _: : perf: subj{np(str)} + {np(str)}
zagonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zagonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zagonić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zagonić: _: : perf: subj{np(str)} + {xp(adl)} + {refl}
zagospodarować się: _: : perf: subj{np(str)} + {xp(locat)}
zagospodarować: _: : perf: subj{np(str)} + obj{np(str)}
zagospodarowywać się: _: : imperf: subj{np(str)} + {xp(locat)}
zagospodarowywać: _: : imperf: 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)}
zagotować się: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zagotować się: _: : perf: {prepnp(w,loc)}
zagotować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zagotować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zagotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zagotować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagotowywać się: _: : imperf: {prepnp(od,gen)} + {xp(locat)}
zagotowywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zagotowywać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
zagotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zagotowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagrabić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagracić się: _: : perf: subj{np(str)} + {np(inst)}
zagracić się: _: : perf: {xp(locat)}
zagracić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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}
zagruntować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zagruntować: _: : perf: subj{np(str)} + {xp(locat)}
zagrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zagrywać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zagryzać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zagryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zagryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zagryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zagryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zagryźć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zagryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zagryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zagryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zagryźć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
zagrzebać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zagrzebać się: _: : perf: subj{np(str)} + {xp(locat)}
zagrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zagrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zagrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
zagrzebać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {xp(locat)}
zagrzebać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)} + {refl}
zagrzebać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)} + {refl}
zagrzebać: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)} + {refl}
zagrzebać: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {xp(locat)} + {refl}
zagrzebywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zagrzebywać się: _: : imperf: subj{np(str)} + {xp(locat)}
zagrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zagrzebywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zagrzebywać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)} + {refl}
zagrzebywać: _: : imperf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)} + {refl}
zagrzebywać: _: : imperf: subj{np(str)} + {prepnp(pod,inst)} + {refl}
zagrzebywać: _: : imperf: subj{np(str)} + {xp(adl)} + {refl}
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}
zagwizdać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zagwizdać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zagwizdać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
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)}
zahamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zahartować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zahartować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zahartować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zahartować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zahartować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
zahartować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zahartować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zahartować: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
zahartować: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
zahartować: _: : perf: subj{np(str)} + {prepnp(przez,acc)} + {refl}
zahartować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zahartować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zahipnotyzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zahuczeć: _: : perf: {np(dat)} + {xp(locat)}
zahuczeć: _: : perf: {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {xp(locat)}
zahuczeć: _: : perf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
zahuczeć: _: : perf: subj{cp(int)} + {xp(locat)}
zahuczeć: _: : perf: subj{cp(że)} + {xp(locat)}
zahuczeć: _: : perf: subj{np(str)} + {cp(int)}
zahuczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zahuczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zahuczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zahuczeć: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
zahuczeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaimplementować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaimplementować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaimplementować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaimponować: _: : perf: subj{cp(int)} + {np(dat)}
zaimponować: _: : perf: subj{cp(jak)} + {np(dat)}
zaimponować: _: : perf: subj{cp(że)} + {np(dat)}
zaimponować: _: : perf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
zaimponować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
zaimportować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zaimportować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zaimpregnować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
zaimpregnować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zaimpregnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zaimpregnować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zaimprowizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zaimprowizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaimprowizować: _: : perf: subj{np(str)} + {or}
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)}
zainscenizować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zaintonować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
zaintonować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zaiskrzyć się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
zaiskrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaiskrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',ratr)}
zaiskrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'widok',ratr)}
zaiskrzyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zaiskrzyć się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaiskrzyć się: _: : perf: subj{np(str)} + {xp(locat)}
zaiskrzyć: _: : perf: {prepnp(między,inst)} + {nonch}
zaiskrzyć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
zaiskrzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaiskrzyć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',ratr)}
zaiskrzyć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'widok',ratr)}
zaiskrzyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zaizolować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zajaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zajaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zajaśnieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zakamuflować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zakamuflować się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
zakamuflować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zakamuflować się: _: : perf: subj{np(str)} + {xp(locat)}
zakamuflować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
zakamuflować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakamuflować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zakamuflować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zakamuflować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zakamuflować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakańczać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)}
zakańczać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
zakańczać się: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zakańczać się: _: : imperf: subj{np(str)} + {xp(locat)}
zakańczać się: _: : imperf: subj{np(str)} + {xp(temp)}
zakańczać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zakańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zakańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {or}
zakańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zakańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakańczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zakatować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zakatować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakatrupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakazać: _: : perf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakazić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zakazić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
zakazywać: _: : imperf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakażać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zakażać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
zakąsić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakąszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakiełkować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zakiełkować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zakiełkować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zakiełkować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zakiełkować: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zakipieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zakipieć: _: : perf: {prepnp(z,gen)} + {xp(locat)}
zakipieć: _: : perf: subj{np(str)} + {np(inst)}
zakipieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zakipieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zaklaskać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaklaskać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zaklaskać: _: : perf: subj{np(str)} + {prepnp(na,acc)}
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}
zakleić się: _: : perf: subj{np(str)} + {np(inst)}
zakleić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaklejać się: _: : imperf: subj{np(str)} + {np(inst)}
zaklejać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaklepać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaklepać: _: : perf: subj{np(str)} + {refl}
zaklepywać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zaklepywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakleszczyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zakleszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zaklinować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaklinować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zaklinować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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łamywać: _: : imperf: subj{np(str)} + {cp(że)} + {refl}
zakłamywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakłopotać się: _: : perf: subj{np(str)} + {cp(że)}
zakłopotać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zakłopotać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zakłopotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
zakłuć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zakłuć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zakłuć: _: : perf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
zakłuć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zakłuć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
zakłuć: _: : perf: subj{np(str)} + {np(str)} + {xp(locat)}
zakłuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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łatać się: _: : perf: subj{cp(że)} + {np(dat)} + {xp(locat)}
zakołatać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zakołatać się: _: : perf: subj{or} + {np(dat)} + {xp(locat)}
zakołatać: _: : perf: subj{cp(że)} + {np(dat)} + {xp(locat)}
zakołatać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zakołatać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zakołatać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zakołatać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zakołatać: _: : perf: subj{np(str)} + {prepnp(o,acc)} + {xp(adl)}
zakołatać: _: : perf: subj{or} + {np(dat)} + {xp(locat)}
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)}
zakomenderować: _: : perf: subj{np(str)} + {cp(int)}
zakomenderować: _: : perf: subj{np(str)} + {cp(że)}
zakomenderować: _: : perf: subj{np(str)} + {cp(żeby)}
zakomenderować: _: : perf: subj{np(str)} + obj{np(str)}
zakomenderować: _: : perf: subj{np(str)} + {or}
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)}
zakonkludować: _: : perf: subj{np(str)} + {cp(że)}
zakonkludować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakonkludować: _: : perf: subj{np(str)} + {or}
zakonserwować się: _: : perf: subj{np(str)}
zakonserwować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zakonserwować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zakonserwować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakonspirować się: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zakonspirować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zakonspirować się: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zakonspirować: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zakonspirować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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)}
zakopać się: _: : perf: subj{np(str)} + {prepnp(pod,acc)}
zakopać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zakopać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zakopać się: _: : perf: subj{np(str)} + {xp(locat)}
zakopać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zakopać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakopcić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zakopcić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
zakopcić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zakopcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zakopcić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakopcić: _: : perf: subj{np(str)} + {xp(abl)}
zakopywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zakopywać się: _: : imperf: subj{np(str)} + {prepnp(pod,acc)}
zakopywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zakopywać się: _: : imperf: subj{np(str)} + {xp(locat)}
zakopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zakopywać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zakotłować się: _: : perf: subj{np(str)}
zakotłować się: _: : perf: {xp(locat)}
zakotłować: _: : perf: subj{np(str)} + {np(inst)}
zakotwiczać się: _: : imperf: subj{np(str)} + {xp(locat)}
zakotwiczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zakotwiczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zakpić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zakpić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
zakpić: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zakradać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zakrakać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zakrakać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zakrakać: _: : perf: subj{np(str)} + {np(dat)} + {or}
zakrakać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zakrakać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
zakrakać: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zakrakać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakrapiać się: _: : imperf: subj{np(str)} + {np(inst)}
zakrapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakrapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zakraść się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zakraść się: _: : perf: subj{np(str)} + {prepadjp(po,postp)} + {xp(adl)}
zakraść się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
zakraść się: _: : perf: subj{np(str)} + {prepnp(pod,acc)} + {xp(adl)}
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)}
zakreślać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zakreślić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zakręcać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
zakręcać się: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(locat)}
zakręcać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
zakręcać: _: : imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',atr)}
zakręcać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakręcać: _: : imperf: subj{np(str)} + {xp(adl)} + {xp(locat)}
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)}
zakropić się: _: : perf: subj{np(str)} + {np(inst)}
zakropić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakropić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
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)}
zakrzątnąć się: _: : perf: subj{np(str)} + {prepnp(koło,gen)}
zakrzątnąć się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
zakrzątnąć się: _: : perf: subj{np(str)} + {prepnp(wokół,gen)}
zakrzątnąć się: _: : perf: subj{np(str)} + {xp(locat)}
zakrztusić się: _: : perf: subj{np(str)} + {np(inst)}
zakrztusić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zakrztusić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
zakrzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zakrzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zakrzyknąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
zakrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zakrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zakrzyknąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zakrzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zakrzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zakrzyknąć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zakrzyknąć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
zakrzywiać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(locat)}
zakrzywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {xp(locat)}
zakrzywiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(locat)}
zakrzywić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(locat)}
zakrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {xp(locat)}
zakrzywić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)} + {xp(locat)}
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)}
zakuć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zakuć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zakuć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zakuć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zakumulować się: _: : perf: subj{np(str)} + {xp(locat)}
zakumulować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zakupywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc)}
zakupywać: _: : imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(za,acc)} + {xp(locat)}
zakurzyć się: _: : perf: {np(dat)} + {xp(locat)}
zakurzyć się: _: : perf: subj{np(str)} + {np(inst)}
zakurzyć: _: : perf: subj{np(str)} + {np(str)}
zakutać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zakutać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zakuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zakuwać: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zakuwać: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zakuwać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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)}
zakwasić się: _: : perf: subj{np(str)} + {np(inst)}
zakwasić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakwaszać się: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
zakwaszać się: _: : imperf: subj{np(str)} + {prepnp(wskutek,gen)}
zakwaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakwaszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,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)}
zakwitać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zakwitać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zakwitać: _: : imperf: subj{np(str)} + {xp(mod)}
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)}
zalakować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zalatywać: _: : imperf: {np(dat)} + {np(inst)} + {xp(abl)}
zalatywać: _: : imperf: {np(inst)} + {prepnp(od,gen)}
zalatywać: _: : imperf: {np(inst)} + {xp(locat)}
zalatywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zalatywać: _: : imperf: subj{np(str)} + {prepnp(od,gen)}
zalatywać: _: : imperf: subj{np(str)} + {xp(abl)}
zalatywać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
zalecieć: _: : perf: {np(inst)} + {xp(abl)}
zalecieć: _: : perf: subj{np(str)} + {np(str)}
zalecieć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zaleczyć się: _: : perf: subj{np(str)} + {np(dat)}
zaleczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zaleczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zalęgnąć się: _: : perf: subj{np(str)} + {xp(locat)}
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}
zalogować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zalogować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zalogować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zalogować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zalśnić się: _: : perf: subj{np(str)} + {np(inst)}
zalśnić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zalśnić: _: : perf: subj{np(str)} + {np(inst)}
zalśnić: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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łączać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
załączać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
załączyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
załączyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
załkać: _: : perf: subj{np(str)} + {cp(że)}
załkać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
załkać: _: : perf: subj{np(str)} + {np(inst)}
załkać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {or}
załomotać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
załomotać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
załomotać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
załomotać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
załomotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
załomotać: _: : perf: subj{or} + {np(dat)} + {xp(locat)}
załopotać: _: : perf: subj{np(str)} + {np(dat)}
załopotać: _: : perf: subj{np(str)} + {np(inst)}
załopotać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
załopotać: _: : perf: subj{np(str)} + {xp(locat)}
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)}
zamajaczyć się: _: : perf: subj{np(str)} + {xp(locat)}
zamajaczyć: _: : perf: subj{cp(że)} + {np(dat)}
zamajaczyć: _: : perf: subj{np(str)} + {np(dat)} + {or}
zamajaczyć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamajaczyć: _: : perf: subj{or} + {np(dat)} + {xp(locat)}
zamalować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zamalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamalować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zamalowywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zamalowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamalowywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zamamrotać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {or}
zamamrotać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(pod,inst,sg,'nos',natr)}
zamamrotać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
zamamrotać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'nos',natr)} + {or}
zamamrotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
zamamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {preplexnp(pod,inst,sg,'nos',natr)}
zamamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {xp(adl)}
zamamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {preplexnp(pod,inst,sg,'nos',natr)}
zamamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(adl)}
zamamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)} + {preplexnp(pod,inst,sg,'nos',natr)}
zamamrotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {preplexnp(pod,inst,sg,'nos',natr)}
zamamrotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {preplexnp(pod,inst,sg,'nos',natr)}
zamamrotać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,sg,'nos',natr)} + {or}
zamanifestować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zamanifestować się: _: : perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zamanifestować się: _: : perf: subj{np(str)} + {xp(locat)}
zamanifestować: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
zamanifestować: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,żeby)}
zamanifestować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
zamarkować: _: : perf: subj{np(str)} + {cp(że)}
zamarkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamartwiać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
zamartwiać się: _: : imperf: subj{np(str)} + {cp(int)}
zamartwiać się: _: : imperf: subj{np(str)} + {cp(że)}
zamartwiać się: _: : imperf: subj{np(str)} + {cp(żeby)}
zamartwiać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zamartwiać się: _: : imperf: subj{np(str)} + {or}
zamartwiać się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zamartwiać się: _: : imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zamartwić się: _: : perf: subj{np(str)} + {cp(gdy)}
zamartwić się: _: : perf: subj{np(str)} + {cp(że)}
zamartwić się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
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)}
zamaskować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zamaskować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamaskować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zamaskować: _: : perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
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)}
zamącić się: _: : perf: {np(dat)} + {prepnp(od,gen)} + {prepnp(w,loc)}
zamącić się: _: : perf: subj{np(str)} + {np(dat)}
zamącić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamącić: _: : perf: 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)}
zamelinować się: _: : perf: subj{np(str)} + {xp(locat)}
zamelinować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamerdać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
zamerdać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zamerdać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zamerdać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {lexnp(inst,_,'ogon',atr)}
zamerykanizować się: _: : perf: subj{np(str)} + {np(dat)}
zamerykanizować: _: : perf: subj{np(str)} + {np(inst)}
zamerykanizować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
zamęczać się: _: : imperf: subj{np(str)} + {cp(że)}
zamęczać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
zamęczać: _: : imperf: subj{np(str); ncp(str,że)} + {np(str)}
zamęczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zamęczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zamęczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zamęczyć: _: : perf: subj{np(str); ncp(str,że)} + {np(str)}
zamęczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zamęczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zamglić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zamglić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zamglić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zamglić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zamigotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamigotać: _: : perf: subj{np(str)} + {np(inst)}
zamigotać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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}
zamoknąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',ratr)}
zamoknąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zamoknąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zamotać się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
zamotać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zamotać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zamotać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
zamotać: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
zamotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zamotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zamotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zamotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zamotać: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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}
zamroczyć: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zamroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
zamruczeć się: _: : perf: subj{np(str)}
zamruczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zamruczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
zamruczeć: _: : perf: subj{np(str)} + {prepadjp(po,postp)} + {or}
zamruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zamruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zamruczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zamruczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zamruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
zamruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
zamruczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)} + {or}
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)}
zamulić się: _: : perf: subj{np(str)} + {np(str)}
zamulić: _: : perf: {np(dat)} + {np(str)}
zamulić: _: : perf: subj{cp(gdy)} + obj{np(str)}
zamulić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zamydlić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(str,pl,'oko',natr)}
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)}
zanieczyszczać się: _: : imperf: subj{np(str)} + {np(inst)}
zanieczyszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zanieczyścić się: _: : perf: subj{np(str)} + {np(inst)}
zanieczyścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zaniemówić: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {cp(gdy); cp(jak); cp(kiedy)}
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)}
zanocować: _: : perf: subj{np(str)} + {xp(locat)}
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)}
zantagonizować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zantagonizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
zantagonizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
zanudzać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
zanudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zanudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zanudzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zanudzać: _: : imperf: subj{np(str)} + {or}
zanudzać: _: : imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
zanudzić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zanudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zanurkować: _: : perf: subj{np(str)} + {prepnp(po,acc)}
zanurkować: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zanurkować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zanurkować: _: : perf: subj{np(str)} + {xp(abl)}
zanurkować: _: : perf: subj{np(str)} + {xp(adl)}
zanurkować: _: : perf: subj{np(str)} + {xp(locat)}
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}
zaofiarować się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zaofiarować się: _: : perf: subj{np(str)} + {cp(że)}
zaofiarować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zaofiarować się: _: : perf: subj{np(str)} + {or}
zaofiarować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
zaofiarować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
zaofiarować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {refl}
zaofiarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zaofiarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zaogniać się: _: : imperf: subj{np(str)}
zaogniać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zaogniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaognić się: _: : perf: subj{np(str)}
zaognić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zaognić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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}
zaoponować: _: : perf: subj{np(str)} + {cp(jakoby)}
zaoponować: _: : perf: subj{np(str)} + {cp(że)}
zaoponować: _: : perf: subj{np(str)} + {cp(żeby)}
zaoponować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zaoponować: _: : perf: subj{np(str)} + {or}
zaoponować: _: : perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,jakoby); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
zaorać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zaorać: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zaorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
zaorać: _: : perf: subj{np(str)} + {prepnp(po,loc)}
zaorać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
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ędzać: _: : imperf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
zaoszczędzać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zaoszczędzać: _: : imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
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)}
zapałać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,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}
zapamiętywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapamiętywać: _: : imperf: subj{np(str)} + {cp(int)}
zapamiętywać: _: : imperf: subj{np(str)} + {cp(jak)}
zapamiętywać: _: : imperf: subj{np(str)} + {cp(że)}
zapamiętywać: _: : imperf: subj{np(str)} + {cp(żeby)}
zapamiętywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
zapamiętywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapamiętywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zapamiętywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby)}
zapamiętywać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
zapamiętywać: _: : imperf: 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)}
zaparować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaparować: _: : perf: subj{np(str)} + obj{np(str)}
zaparować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zapaskudzić się: _: : perf: subj{np(str)} + {np(inst)}
zapaskudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
zapchać się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapchać się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zapchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapchać: _: : perf: subj{np(str)} + obj{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)}
zaperzyć się: _: : perf: subj{np(str)} + {cp(że)}
zaperzyć się: _: : perf: subj{np(str)} + {np(dat)}
zaperzyć się: _: : perf: subj{np(str)} + {or}
zaperzyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zaperzyć się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zapeszać się: _: : imperf: subj{np(str)} + {np(inst)}
zapeszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zapeszyć się: _: : perf: subj{np(str)} + {np(inst)}
zapeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
zapędzać się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
zapędzać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zapędzać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zapędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zapędzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zapędzić się: _: : perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
zapędzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zapędzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zapędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zapędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zapędzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zapętlać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zapętlać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapętlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zapętlać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zapętlić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zapętlić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapętlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zapętlić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zapiać: _: : perf: subj{np(str)} + {cp(int)}
zapiać: _: : perf: subj{np(str)} + {cp(że)}
zapiać: _: : perf: subj{np(str)} + {or}
zapiać: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zapiać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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}
zapić się: _: : perf: subj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zapić się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zapić się: _: : perf: subj{np(str)} + {preplexnp(w,acc,sg,'trup',natr)}
zapić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zapić się: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zapić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapić: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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)}
zapieczętować: _: : perf: subj{np(str)} + obj{np(str)} + {np(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)}
zapienić się: _: : perf: subj{np(str)} + {cp(int)}
zapienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
zapienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zapienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zapienić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zapienić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zapienić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zapierać się: _: : imperf: subj{np(str)} + {cp(jakoby)}
zapierać się: _: : imperf: subj{np(str)} + {cp(że)}
zapierać się: _: : imperf: subj{np(str)} + {cp(żeby)}
zapierać się: _: : imperf: subj{np(str)} + {np(gen); ncp(gen,jakoby); ncp(gen,że)}
zapierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zapierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
zapierać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zapierać się: _: : imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
zapierać się: _: : imperf: subj{np(str)} + {or}
zapierać się: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zapierać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)}
zapierać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zapierać: _: : imperf: {np(dat)} + {np(str)} + {prepnp(z,gen)}
zapierać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)}
zapierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zapierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zapijać się: _: : imperf: subj{np(str)} + {np(inst)}
zapijać się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'amen',natr)}
zapijać się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zapijać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapinać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(mod)}
zapinać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zapinać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapinać: _: : imperf: subj{np(str)} + {refl}
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}
zaplamić się: _: : perf: subj{np(str)} + {np(inst)}
zaplamić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaplamić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zaplamić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zaplombować się: _: : perf: subj{np(str)} + {xp(locat)}
zaplombować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaplombować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zapluć się: _: : perf: subj{np(str)} + {np(inst)}
zapluć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zapluć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapluć: _: : perf: subj{np(str)} + {refl}
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ładniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapładniać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zapłakać się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zapłakać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zapłakać: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zapłakać: _: : perf: subj{np(str)} + {prepnp(po,loc)}
zapłakać: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zapłodnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapłodnić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
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)}
zapodać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {xp(adl)}
zapodać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {xp(locat)}
zapodać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(adl)}
zapodać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {xp(locat)}
zapodać: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {or}
zapodać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)} + {or}
zapodać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zapodać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zapodać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zapodać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zapożyczać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen)}
zapożyczać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zapożyczać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zapożyczyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen)}
zapożyczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zapożyczyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zapracować się: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zapracować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zapracowywać się: _: : imperf: subj{np(str)} + {preplexnp(na,acc,sg,'śmierć',natr)}
zapracowywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zapracowywać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zapragnąć: _: : perf: subj,controller{np(str)} + controllee{cp(żeby); infp(_)}
zapragnąć: _: : perf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
zaprasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(mod)}
zaprasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
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)}
zaprocentować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
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)}
zaprotokołować: _: : perf: subj{np(str)} + {cp(że)}
zaprotokołować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)}
zaprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zaprowadzać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zaprowadzić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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ąc: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaprząc: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaprząc: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
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}
zaprzeć się: _: : perf: subj{np(str)} + {cp(jakoby)}
zaprzeć się: _: : perf: subj{np(str)} + {cp(że)}
zaprzeć się: _: : perf: subj{np(str)} + {cp(żeby)}
zaprzeć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,jakoby); ncp(gen,że)}
zaprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zaprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
zaprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zaprzeć się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaprzeć się: _: : perf: subj{np(str)} + {or}
zaprzeć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zaprzeć się: _: : perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)}
zaprzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaprzeć: _: : perf: {np(dat)} + {np(str)} + {prepnp(z,gen)}
zaprzeć: _: : perf: subj{np(str)} + {np(dat)} + {np(str)}
zaprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zaprzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaprzedać się: _: : perf: subj{np(str)} + {np(dat)}
zaprzedać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaprzedawać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zaprzedawać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zaprzepaszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaprzepaścić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
zaprzęgać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zaprzęgać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaprzęgać: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaprzęgać: _: : imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zaprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zaprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zaprzęgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaprzęgnąć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaprzęgnąć: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
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}
zapuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zapuchnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zapukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zapukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zapukać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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)}
zapychać się: _: : imperf: subj{np(str)} + {np(inst)}
zapychać: _: : imperf: subj{np(str)} + {np(inst)} + {refl}
zapychać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zarachować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)} + {advp(misc)}
zaradzać: _: : imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
zaradzać: _: : imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
zaradzić: _: : perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
zaradzić: _: : perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
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)}
zarąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zarąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zarchiwizować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zarchiwizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zardzewieć: _: : perf: subj{np(str)} + {np(dat)}
zardzewieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zardzewieć: _: : perf: subj{np(str)} + {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)}
zareplikować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zareplikować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
zareplikować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
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)}
zarobkować: _: : imperf: subj{np(str)} + {np(inst)}
zarobkować: _: : imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zarobkować: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
zaróżowić się: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zaróżowić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaróżowić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zaróżowić się: _: : perf: subj{np(str)} + {np(inst)}
zaróżowić: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zarybiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarybić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaryczeć się: _: : perf: subj{np(str)}
zaryczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {xp(perl)}
zaryczeć: _: : perf: subj{np(str)} + {np(inst)}
zaryczeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
zaryczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)} + {xp(perl)}
zaryczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {xp(perl)}
zaryczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(perl)} + {or}
zaryczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)} + {xp(perl)}
zaryczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)} + {xp(perl)}
zaryczeć: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(perl)} + {or}
zaryć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zaryć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zaryć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zaryć: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zaryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaryć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaryglować się: _: : perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaryglować się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
zaryglować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaryglować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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}
zarzekać się: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zarzekać się: _: : imperf: subj{np(str)} + {np(gen)}
zarzekać się: _: : imperf: 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)}
zarzygać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zasapać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zasapać: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {or}
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)}
zasępiać się: _: : imperf: subj{np(str)} + {np(dat)}
zasępiać się: _: : imperf: subj{np(str)} + {np(inst)}
zasępiać się: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
zasępiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zasępić się: _: : perf: subj{np(str)} + {np(dat)}
zasępić się: _: : perf: subj{np(str)} + {np(inst)}
zasępić się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zasępić: _: : 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)}
zaskarbiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)}
zaskarbiać: _: : imperf: subj{np(str)} + {np(dat)} + {np(str)} + {xp(locat)}
zaskarbić: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)} + {np(str)}
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)}
zaskowyczeć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(nad,inst)}
zaskowyczeć: _: : perf: {prepnp(w,loc)} + {or}
zaskowyczeć: _: : perf: {prepnp(z,gen)} + {xp(locat)}
zaskowyczeć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zaskowyczeć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
zaskowyczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zaskowyczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zaskowyczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaskowyczeć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaskowyczeć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zaskowyczeć: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zaskowyczeć: _: : perf: subj{np(str)} + {xp(adl)}
zaskowyczeć: _: : perf: subj{np(str)} + {xp(locat)}
zaskowyczeć: _: : perf: subj{np(str)} + {xp(mod)}
zaskrzeczeć: _: : perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
zaskrzeczeć: _: : perf: subj{np(str)} + {cp(że)}
zaskrzeczeć: _: : perf: subj{np(str)} + {np(inst)}
zaskrzeczeć: _: : perf: subj{np(str)} + {np(str)} + {prepadjp(po,postp)}
zaskrzeczeć: _: : perf: subj{np(str)} + {or}
zaskrzeczeć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaskrzeczeć: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
zaskrzypieć: _: : perf: {np(dat)} + {xp(locat)}
zaskrzypieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zasłabnąć: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zasłabnąć: _: : perf: subj{np(str)} + {np(dat)}
zasłabnąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zasłabnąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zasłać się: _: : perf: subj{np(str)} + {np(inst)}
zasłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasłać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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łuchać się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
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)}
zasmarować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasmucać się: _: : imperf: subj{np(str)} + {comprepnp(z powodu)}
zasmucać się: _: : imperf: subj{np(str)} + {cp(int)}
zasmucać się: _: : imperf: subj{np(str)} + {cp(że)}
zasmucać się: _: : imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zasmucać się: _: : imperf: subj{np(str)} + {or}
zasmucać: _: : imperf: subj{cp(gdy)} + {np(str)}
zasmucać: _: : imperf: subj{cp(int)} + {np(str)}
zasmucać: _: : imperf: subj{cp(jak)} + {np(str)}
zasmucać: _: : imperf: subj{cp(jeśli)} + {np(str)}
zasmucać: _: : imperf: subj{cp(kiedy)} + {np(str)}
zasmucać: _: : imperf: subj{cp(że)} + {np(str)}
zasmucać: _: : imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zasmucać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
zasnuć się: _: : perf: subj{np(str)} + {np(inst)}
zasnuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasnuwać się: _: : imperf: subj{np(str)} + {np(inst)}
zasnuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasobny: : : : {preplexnp(z,gen,sg,'dom',natr)}
zasobny: : : : {prepnp(o,acc)}
zasobny: : : : {prepnp(w,acc)}
zasolić się: _: : perf: subj{np(str)}
zasolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zassać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zassać: _: : perf: {np(str)} + {xp(locat)}
zassać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
zastopować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zastopować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastopować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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)}
zasunąć się: _: : perf: subj{np(str)} + {np(inst)}
zasunąć się: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zasunąć się: _: : perf: subj{np(str)} + {xp(adl)}
zasunąć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zasunąć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zasunąć: _: : perf: subj{np(str)} + {np(dat)} + {or}
zasunąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zasunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasunąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zasunąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
zasunąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zasunąć: _: : perf: subj{np(str)} + {prepadjp(po,postp)}
zasuszać się: _: : imperf: subj{np(str)} + {xp(locat)}
zasuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasuszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zasuwać się: _: : imperf: subj{np(str)} + {np(inst)}
zasuwać się: _: : imperf: subj{np(str)} + {prepnp(za,inst)}
zasuwać się: _: : imperf: subj{np(str)} + {xp(adl)}
zasuwać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zasuwać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zasuwać: _: : imperf: subj{np(str)} + {np(dat)} + {or}
zasuwać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
zasuwać: _: : imperf: subj{np(str)} + {np(inst)}
zasuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zasuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
zasuwać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zasuwać: _: : imperf: subj{np(str)} + {prepadjp(po,postp)}
zasuwać: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
zasymilować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zasymilować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zasymilować się: _: : perf: subj{np(str)} + {xp(locat)}
zasymilować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zasymilować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zasymilować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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}
zaszachować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zaszczycać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaszczycić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaszeleścić: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaszeleścić: _: : perf: subj{np(str)} + {np(inst)}
zaszeleścić: _: : perf: subj{np(str)} + {or}
zaszeleścić: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
zaszemrać: _: : perf: {np(inst)} + {xp(locat)}
zaszemrać: _: : perf: subj{np(str)} + {np(inst)}
zaszemrać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zaszemrać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zaszemrać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zaszemrać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zaszemrać: _: : perf: subj{np(str)} + {xp(locat)}
zaszemrać: _: : perf: subj{or} + {xp(locat)}
zaszeptać: _: : perf: subj{np(str)} + {cp(int)} + {preplexnp(między,inst,sg,'siebie',natr)}
zaszeptać: _: : perf: subj{np(str)} + {cp(żeby)} + {preplexnp(między,inst,sg,'siebie',natr)}
zaszeptać: _: : perf: subj{np(str)} + {cp(że)} + {preplexnp(między,inst,sg,'siebie',natr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(do,gen,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(na,acc,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
zaszeptać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {preplexnp(na,acc,sg,'ucho',ratr)}
zaszeptać: _: : perf: 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)}
zaszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
zaszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)}
zaszeptać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaszeptać: _: : perf: subj{np(str)} + {prepadjp(po,postp)} + {preplexnp(między,inst,sg,'siebie',natr)}
zaszeptać: _: : perf: subj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)} + {or}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {preplexnp(między,inst,sg,'siebie',natr)}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
zaszeptać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
zaszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(jako,str)}
zaszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaszeregować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(jako,str)}
zaszeregować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaszklić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaszklić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zaszklić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zaszlachtować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaszlochać: _: : perf: subj{np(str)} + {cp(int)}
zaszlochać: _: : perf: subj{np(str)} + {cp(że)}
zaszlochać: _: : perf: subj{np(str)} + {or}
zaszlochać: _: : perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zaszlochać: _: : perf: subj{np(str)} + {prepnp(za,inst)}
zasznurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasznurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zasznurować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zaszufladkować: _: : perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
zaszufladkować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
zaszufladkować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zaszufladkować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zaszufladkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaszufladkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaszufladkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
zaszufladkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaszufladkować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaszufladkować: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaszufladkować: _: : perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zaszufladkować: _: : perf: subj{np(str)} + {prepnp(według,gen)} + {refl}
zaszufladkować: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zaszufladkować: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
zaszumieć: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zaszumieć: _: : perf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
zaszumieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zaszumieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zaszumieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
zaszumieć: _: : perf: subj{np(str)} + {np(inst)}
zaszumieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zaszurać: _: : perf: subj{np(str)} + {np(dat)}
zaszurać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zaszurać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zaszurać: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zaszurać: _: : perf: subj{np(str)} + {xp(locat)}
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)}
zaszywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zaszywać się: _: : imperf: subj{np(str)} + {xp(locat)}
zaszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
zaszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaścielać się: _: : imperf: subj{np(str)} + {np(inst)}
zaścielać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaścielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaślepiać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
zaślepiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaślepić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
zaślepić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaślinić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zaślinić: _: : 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śmiewać się: _: : imperf: subj{np(str)} + {or}
zaśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zaśmiewać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
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świadczać: _: : imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
zaświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zaświadczać: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaświadczać: _: : imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zaświadczać: _: : imperf: subj{np(str)} + {or}
zaświadczyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
zaświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zaświadczyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaświadczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zaświadczyć: _: : perf: subj{np(str)} + {or}
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świstać: _: : perf: subj{np(str)} + {advp(misc)}
zaświstać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zaświstać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
zaświstać: _: : perf: subj{np(str)} + obj{np(str)}
zaświstać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zaświstać: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zaświstać: _: : perf: subj{np(str)} + {xp(abl)}
zaświstać: _: : perf: subj{np(str)} + {xp(mod)}
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)}
zatamować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatankować: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('do pełna')}
zatankować: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('pod korek')}
zatankować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zatankować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zatańczyć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
zatańczyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zatańczyć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zatańczyć: _: : perf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
zatapiać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
zatapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zatapiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zatarasować się: _: : perf: subj{np(str)} + {xp(locat)}
zatarasować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatargać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zatargać: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zatargać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
zatargać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
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)}
zaterkotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaterkotać: _: : perf: subj{np(str)} + {np(inst)}
zaterkotać: _: : perf: subj{np(str)} + {prepnp(o,acc)}
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)}
zatkać się: _: : perf: subj{np(str)} + {np(inst)}
zatkać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zatkać: _: : perf: {np(str)} + {cp(gdy)}
zatkać: _: : perf: {np(str)} + {cp(jak)}
zatkać: _: : perf: {np(str)} + {cp(kiedy)}
zatkać: _: : perf: {np(str)} + {prepnp(z,gen)}
zatkać: _: : perf: subj{cp(że)} + {np(str)}
zatkać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {lexnp(str,sg,'dech',natr)} + {preplexnp(w,loc,_,'pierś',natr)}
zatkać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zatkać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zatkać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatkać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,pl,'ucho',natr)}
zatknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zatknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zatknąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zatknąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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łuc się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatłuc się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zatłuc: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
zatłuc: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
zatomizować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zatomizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zatonąć: _: : perf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
zatopić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zatopić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zatopić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zatrąbić: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zatrąbić: _: : perf: subj{np(str)} + {cp(int)} + {xp(abl)}
zatrąbić: _: : perf: subj{np(str)} + {cp(int)} + {xp(adl)}
zatrąbić: _: : perf: subj{np(str)} + {cp(int)} + {xp(locat)}
zatrąbić: _: : perf: subj{np(str)} + {cp(żeby)} + {xp(abl)}
zatrąbić: _: : perf: subj{np(str)} + {cp(żeby)} + {xp(adl)}
zatrąbić: _: : perf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
zatrąbić: _: : perf: subj{np(str)} + {cp(że)} + {xp(abl)}
zatrąbić: _: : perf: subj{np(str)} + {cp(że)} + {xp(adl)}
zatrąbić: _: : perf: subj{np(str)} + {cp(że)} + {xp(locat)}
zatrąbić: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zatrąbić: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zatrąbić: _: : perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zatrąbić: _: : perf: subj{np(str)} + {np(dat)} + {or}
zatrąbić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zatrąbić: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zatrąbić: _: : perf: subj{np(str)} + {np(inst)}
zatrąbić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(abl)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(adl)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zatrąbić: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zatrąbić: _: : perf: subj{np(str)} + {xp(abl)} + {or}
zatrąbić: _: : perf: subj{np(str)} + {xp(adl)} + {or}
zatrąbić: _: : perf: subj{np(str)} + {xp(locat)} + {or}
zatrącać: _: : imperf: subj{np(str)} + {cp(że)}
zatrącać: _: : imperf: subj{np(str)} + {np(inst)}
zatrącać: _: : imperf: subj{np(str)} + {or}
zatrącać: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
zatriumfować: _: : perf: subj{np(str)} + {cp(że)}
zatriumfować: _: : perf: subj{np(str)} + {np(inst)}
zatriumfować: _: : perf: subj{np(str)} + {or}
zatriumfować: _: : perf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
zatroskać się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zatroskać się: _: : perf: subj{np(str)} + {cp(int)}
zatroskać się: _: : perf: subj{np(str)} + {cp(że)}
zatroskać się: _: : perf: subj{np(str)} + {cp(żeby)}
zatroskać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zatroskać się: _: : perf: subj{np(str)} + {or}
zatroskać się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
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)}
zatrwożyć się: _: : perf: subj{np(str)} + {cp(int)}
zatrwożyć się: _: : perf: subj{np(str)} + {cp(że)}
zatrwożyć się: _: : perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
zatrwożyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zatrwożyć się: _: : perf: subj{np(str)} + {or}
zatrwożyć się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zatrwożyć: _: : perf: subj{cp(że)} + {np(str)}
zatrwożyć: _: : perf: subj{np(str); ncp(str,że)} + obj{np(str)}
zatrwożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)}
zatrzepotać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatrzepotać się: _: : perf: subj{np(str)} + {np(inst)}
zatrzepotać się: _: : perf: subj{np(str)} + {or}
zatrzepotać się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zatrzepotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatrzepotać: _: : perf: subj{np(str)} + {np(inst)}
zatrzepotać: _: : perf: subj{np(str)} + {or}
zatrzepotać: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zatrzepotać: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zatrzeszczeć: _: : perf: {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
zatrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zatrzeszczeć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatrzeszczeć: _: : perf: subj{np(str)} + {np(inst)}
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)}
zatuszować: _: : perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
zatuszować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(inst)}
zatuszować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,że)}
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)}
zatykać się: _: : perf: subj{np(str)} + {np(inst)}
zatykać się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zatykać: _: : perf: {np(str)} + {cp(gdy)}
zatykać: _: : perf: {np(str)} + {cp(jak)}
zatykać: _: : perf: {np(str)} + {cp(kiedy)}
zatykać: _: : perf: {np(str)} + {prepnp(w,loc)}
zatykać: _: : perf: {np(str)} + {prepnp(z,gen)}
zatykać: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {lexnp(str,sg,'dech',natr)} + {preplexnp(w,loc,_,'pierś',natr)}
zatykać: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zatykać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zatykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zatykać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zatykać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zatykać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,pl,'ucho',natr)}
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)}
zauroczyć się: _: : perf: subj{np(str)} + {np(inst)}
zauroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zawalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zawalać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zawalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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}
zawarować: _: : perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zawarować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zawarować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zaważyć: _: : perf: subj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
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)}
zawezwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zawezwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zawezwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {xp(adl)}
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)}
zawiać: _: : perf: {np(dat)} + {np(inst)} + {xp(locat)}
zawiać: _: : perf: {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
zawiać: _: : perf: subj{E} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zawiać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zawiać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zawiać: _: : perf: subj{np(str)} + {prepnp(w,acc)}
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)}
zawieruszyć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zawieruszyć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zawierzać: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zawierzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zawierzyć: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zawierzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
zawieść się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zawieść się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zawieść: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zawieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zawieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zawieść: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawieść: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zawiewać: _: : imperf: {np(dat)} + {np(inst)} + {xp(locat)}
zawiewać: _: : imperf: {np(inst)} + {xp(adl)}
zawiewać: _: : imperf: subj{E} + obj{np(str)} + {np(inst)}
zawiewać: _: : imperf: subj{E} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zawiewać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zawiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zawiewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zawiewać: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zawieźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
zawirować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zawirować: _: : perf: {np(dat)} + {prepnp(w,loc)}
zawirować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przed,inst)}
zawirować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zawisać: _: : imperf: subj{np(str)} + {prepnp(nad,inst)}
zawisać: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(inst,sg,'wzrok',natr)}
zawisać: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zawisać: _: : imperf: subj{np(str)} + {xp(locat)}
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)}
zawlec się: _: : perf: subj{np(str)} + {np(inst)}
zawlec się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zawlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
zawoalować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
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}
zawojować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
zawozić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
zawtórować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
zawtórować: _: : perf: subj{np(str)} + {np(dat)} + {or}
zawtórować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
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)}
zawyrokować: _: : perf: subj{np(str)} + {comprepnp(co do)}
zawyrokować: _: : perf: subj{np(str)} + {comprepnp(na temat)}
zawyrokować: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
zawyrokować: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zawyrokować: _: : perf: subj{np(str)} + {cp(int)}
zawyrokować: _: : perf: subj{np(str)} + {cp(że)}
zawyrokować: _: : perf: subj{np(str)} + {or}
zawyrokować: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
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)}
zawziąć się: _: : perf: subj,controller{np(str)} + controllee{infp(_)}
zawziąć się: _: : perf: subj{np(str)} + {cp(że)}
zawziąć się: _: : perf: subj{np(str)} + {cp(żeby)}
zawziąć się: _: : perf: subj{np(str)} + {or}
zawziąć się: _: : perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zazdrościć: _: : imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że)}
zazębiać się: _: : imperf: subj{np(str)} + {prepnp(o,acc)}
zazębiać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zazębić się: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zazębić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zazgrzytać: _: : perf: {prepnp(pomiędzy,inst)}
zazgrzytać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zazgrzytać: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zazielenić się: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zazielenić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zazielenić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zazielenić się: _: : perf: subj{np(str)} + {np(inst)}
zazielenić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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}
zaznać: _: : perf: subj{np(str)} + {np(gen)}
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)}
zaznawać: _: : imperf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(przed,inst)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {comprepnp(co do)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {comprepnp(na temat)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {comprepnp(w kwestii)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(jak)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zaznawać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
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żerać się: _: : imperf: subj{np(str)} + {np(inst)}
zażerać: _: : imperf: subj{np(str)} + obj{np(str)}
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)}
zbagatelizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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}
zbanalizować się: _: : perf: subj{np(str)}
zbanalizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
zbankrutować: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zbaranieć: _: : perf: subj{np(str)} + {or}
zbaranieć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zbaranieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zbaranieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zbaranieć: _: : perf: subj{np(str)} + {xp(mod)}
zbaranieć: _: : perf: subj{np(str)} + {xp(temp)}
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)}
zbesztać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zbesztać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zbesztać: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
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)}
zbiednieć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zbiednieć: _: : perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
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)}
zbiurokratyzować się: _: : perf: subj{np(str)} + {np(dat)}
zbiurokratyzować: _: : perf: subj{np(str)} + obj{np(str)}
zblaknąć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zblaknąć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
zblokować się: _: : perf: subj{np(str)} + {np(dat)}
zblokować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zblokować: _: : perf: {np(dat)} + {np(str)}
zblokować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zblokować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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)}
zbłądzić: _: : perf: subj{np(str)} + {xp(adl)}
zbłądzić: _: : perf: subj{np(str)} + {xp(locat)}
zboczyć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zboczyć: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zbojkotować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zbraknąć: _: : perf: {np(dat)} + {np(gen)} + {cp(żeby)}
zbraknąć: _: : perf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zbraknąć: _: : perf: {np(dat)} + {prepnp(dla,gen)} + {lexnp(gen,pl,'słowo',atr)}
zbraknąć: _: : perf: {np(dat)} + {prepnp(na,acc)} + {lexnp(gen,pl,'słowo',atr)}
zbraknąć: _: : perf: {np(gen)} + {xp(locat)}
zbratać się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zbratać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zbroczyć się: _: : perf: subj{np(str)} + {np(inst)}
zbroczyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zbroczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zbrukać: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zbrukać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zbrukać: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
zbryzgać się: _: : perf: subj{np(str)} + {np(inst)}
zbryzgać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zbrzydnąć: _: : perf: subj{cp(int)} + {np(dat)}
zbrzydnąć: _: : perf: subj{cp(że)} + {np(dat)}
zbrzydnąć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zbrzydzić się: _: : perf: subj{np(str)} + {np(dat)}
zbrzydzić się: _: : perf: subj{np(str)} + {np(inst)}
zbrzydzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
zbudzić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zbudzić się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zbudzić się: _: : perf: subj{np(str)} + {prepnp(między,inst)}
zbudzić się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zbudzić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zbudzić się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zbudzić się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zbudzić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zbudzić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
zbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
zbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
zbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zbudzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
zbutwieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
zbutwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(w,acc)}
zbutwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zbutwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
zbutwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zbutwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zbutwieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
zdecentralizować się: _: : perf: subj{np(str)}
zdecentralizować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zdefektować: _: : perf: subj{np(str)} + {np(dat)}
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)}
zdefraudować: _: : perf: subj{np(str)} + obj{np(str)}
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}
zdeklasować się: _: : perf: subj{np(str)}
zdeklasować: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',ratr)}
zdeklasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zdeklasować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zdekompletować się: _: : perf: subj{np(str)} + {np(dat)}
zdekompletować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zdekoncentrować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdekoncentrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdekonspirować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
zdekonspirować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zdelegalizować: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zdelegalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdemaskować: _: : perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
zdemaskować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
zdemaskować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zdematerializować się: _: : perf: subj{np(str)} + {xp(locat)}
zdematerializować: _: : perf: subj{np(str)} + obj{np(str)}
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}
zdemilitaryzować: _: : perf: subj{np(str)} + obj{np(str)}
zdemobilizować się: _: : perf: subj{np(str)} + {advp(misc)}
zdemobilizować: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zdemokratyzować się: _: : perf: subj{np(str)}
zdemokratyzować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zdeprawować się: _: : perf: subj{np(str)}
zdeprawować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdeprecjonować się: _: : perf: subj{np(str)}
zdeprecjonować: _: : perf: subj{np(str)} + obj{np(str)}
zdeprymować się: _: : perf: subj{np(str)} + {cp(int)}
zdeprymować się: _: : perf: subj{np(str)} + {cp(że)}
zdeprymować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdeprymować: _: : perf: subj{cp(gdy)} + {np(str)}
zdeprymować: _: : perf: subj{cp(int)} + {np(str)}
zdeprymować: _: : perf: subj{cp(jak)} + {np(str)}
zdeprymować: _: : perf: subj{cp(kiedy)} + {np(str)}
zdeprymować: _: : perf: subj{cp(że)} + {np(str)}
zdeprymować: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zdeprymować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)} + {np(str)}
zdeptać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
zdetronizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdetronizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zdetronizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zdetronizować: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
zdewaluować się: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
zdewaluować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
zdewastować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdezaktualizować się: _: : perf: subj{np(str)}
zdezaktualizować: _: : perf: subj{np(str)} + obj{np(str)}
zdezawuować się: _: : perf: subj{np(str)}
zdezawuować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zdezawuować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zdezelować się: _: : perf: subj{np(str)} + {np(dat)}
zdezelować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdezerterować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zdezorganizować się: _: : perf: subj{np(str)}
zdezorganizować: _: : 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)}
zdezynfekować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdębieć: _: : perf: subj{np(str)} + {cp(że)}
zdębieć: _: : perf: subj{np(str)} + {or}
zdębieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
zdławić się: _: : perf: subj{np(str)} + {np(inst)}
zdławić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdławić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zdmuchiwać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zdmuchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zdmuchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zdmuchnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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(_)}
zdołować się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zdołować się: _: : perf: subj{np(str)} + {cp(int)}
zdołować się: _: : perf: subj{np(str)} + {cp(że)}
zdołować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdołować się: _: : perf: subj{np(str)} + {or}
zdołować: _: : perf: subj{cp(gdy)} + {np(str)}
zdołować: _: : perf: subj{cp(int)} + {np(str)}
zdołować: _: : perf: subj{cp(jak)} + {np(str)}
zdołować: _: : perf: subj{cp(jeśli)} + {np(str)}
zdołować: _: : perf: subj{cp(kiedy)} + {np(str)}
zdołować: _: : perf: subj{cp(że)} + {np(str)}
zdołować: _: : 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)}
zdołować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zdołować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zdołować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdołować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
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)}
zdrabniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zdrabniać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zdrabniać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
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)}
zdrapać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zdrapywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zdrętwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zdrętwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
zdrzemnąć się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zdrzemnąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(u,gen)}
zdrzemnąć się: _: : perf: subj{np(str)} + {xp(dur)}
zdrzemnąć się: _: : perf: subj{np(str)} + {xp(locat)}
zdublować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zdublować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zdurnieć: _: : perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
zdurnieć: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zdurnieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zdurnieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zdurnieć: _: : perf: subj{np(str)} + {xp(locat)}
zdusić: _: : perf: subj{np(str)} + obj{np(str)} + {fixed('w zalążku')}
zdusić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdwoić się: _: : perf: subj{np(str)}
zdwoić: _: : perf: subj{np(str)} + obj{np(str)}
zdybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
zdybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
zdybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zdybać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zdybać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zdybać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
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)}
zdyskontować się: _: : perf: subj{np(str)}
zdyskontować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
zdyskredytować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zdyskredytować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
zdyskredytować: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(wobec,gen)} + {refl}
zdyskredytować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(przed,inst)}
zdyskredytować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(wobec,gen)}
zdyskredytować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
zdyskredytować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(wobec,gen)}
zdyskredytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
zdyskredytować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(wobec,gen)}
zdyskredytować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zdyskredytować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {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)}
zdysocjować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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)}
zdywersyfikować się: _: : perf: subj{np(str)}
zdywersyfikować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zdziecinnieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zdziecinnieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zdzielić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(między,acc)} + {refl}
zdzielić: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(między,acc)}
zdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
zdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zdzielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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)}
zdzierżyć: _: : perf: subj{np(str)} + {cp(gdy)}
zdzierżyć: _: : perf: subj{np(str)} + {cp(int)}
zdzierżyć: _: : perf: subj{np(str)} + {cp(jak)}
zdzierżyć: _: : perf: subj{np(str)} + {cp(kiedy)}
zdzierżyć: _: : perf: subj{np(str)} + {cp(że)}
zdzierżyć: _: : perf: subj{np(str)} + {np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
zdziesiątkować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zegnać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zegnać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zegnać: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
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)}
zekranizować: _: : perf: subj{np(str)} + obj{np(str)}
zelektryfikować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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żeć: _: : perf: subj{np(str)} + {np(dat)}
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)}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {cp(int)}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {or}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'oko',atr)}
zełgać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zełgać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zemdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zemdleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zemdlić: _: : perf: {np(str)} + {prepnp(od,gen)}
zemdlić: _: : perf: {np(str)} + {prepnp(z,gen)}
zemdlić: _: : perf: subj{np(str)} + {np(str)}
zemleć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zemleć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zemleć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zemleć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zemleć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
zerwać się: _: : perf: subj{np(str)} + {or}
zerwać się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zerwać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zerwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zerwać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zerwać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zerwać: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zerżnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zerżnąć: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zerżnąć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zeschnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
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)}
zeskrobać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zeskrobywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {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)}
zespawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zespawać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {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)}
zestarzeć się: _: : perf: subj{np(str)}
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)}
zestroić się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zestroić się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zestroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zestroić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
zeszczupleć: _: : perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
zeszczupleć: _: : perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
zeszczupleć: _: : perf: subj{np(str)} + {xp(locat)}
zeszklić się: _: : perf: subj{np(str)} + {np(inst)}
zeszklić: _: : perf: {np(inst)} + {np(str)}
zeszklić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
zeszklić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(mod)}
zeszmacić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
zeszmacić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
zeszpecić: _: : perf: subj{np(str)} + {np(inst)} + {refl}
zeszpecić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,inst)}
ześlizgiwać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
ześlizgiwać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
ześlizgiwać się: _: : imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
ześlizgiwać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(adl)}
ześlizgnąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
ześlizgnąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
ześlizgnąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
ześlizgnąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
ześlizgnąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
ześliznąć się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)}
ześliznąć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
ześliznąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
ześliznąć się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
ześliznąć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
ześrodkować się: _: : _: subj{np(str)} + {xp(locat)}
ześrodkować: _: : _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ześrodkować: _: : _: subj{np(str)} + obj{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)}
zewrzeć się: _: : perf: subj{np(str)} + {np(dat)}
zewrzeć się: _: : perf: subj{np(str)} + {np(inst)}
zewrzeć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zewrzeć się: _: : perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zewrzeć się: _: : perf: subj{np(str)} + {xp(locat)}
zewrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zewrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zewrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zewrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zewrzeć: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zezłomować: _: : perf: subj{np(str)} + obj{np(str)}
zezłościć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zezłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
zezłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zezłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zezłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zezłościć się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zezłościć: _: : perf: subj{cp(gdy)} + {np(str)}
zezłościć: _: : perf: subj{cp(jak)} + {np(str)}
zezłościć: _: : perf: subj{cp(jeśli)} + {np(str)}
zezłościć: _: : perf: subj{cp(kiedy)} + {np(str)}
zezłościć: _: : perf: subj{cp(że)} + {np(str)}
zezł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)}
zezłościć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
zezować: _: : imperf: subj{np(str)} + {cp(int)}
zezować: _: : imperf: subj{np(str)} + {cp(jak)}
zezować: _: : imperf: subj{np(str)} + {prepnp(ku,dat)}
zezować: _: : imperf: subj{np(str)} + {prepnp(na,acc)}
zezować: _: : imperf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
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źlić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
zeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zeźlić się: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zeźlić: _: : perf: subj{cp(gdy)} + {np(str)}
zeźlić: _: : perf: subj{cp(int)} + {np(str)}
zeźlić: _: : perf: subj{cp(jak)} + {np(str)}
zeźlić: _: : perf: subj{cp(jeśli)} + {np(str)}
zeźlić: _: : perf: subj{cp(kiedy)} + {np(str)}
zeźlić: _: : perf: subj{cp(że)} + {np(str)}
zeźlić: _: : 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)}
zeźlić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
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)}
zganiać się: _: : perf: subj{np(str)}
zganiać się: _: : imperf: subj{np(str)} + {xp(locat)}
zganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zganiać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zganiać: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
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}
zgarbić się: _: : perf: subj{np(str)} + {prepnp(nad,inst)}
zgarbić się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zgarbić się: _: : perf: subj{np(str)} + {prepnp(pod,inst)}
zgarbić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zgarbić: _: : perf: subj{np(str)} + {np(str)}
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)}
zgermanizować się: _: : perf: subj{np(str)}
zgermanizować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + controllee{prepnp(z,gen)}
zgęstnieć: _: : perf: {prepnp(od,gen)} + {xp(locat)}
zgęstnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zgęstnieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgęścić się: _: : perf: subj{np(str)}
zgęścić: _: : perf: subj{np(str)} + obj{np(str)}
zgęścić: _: : perf: subj{np(str)} + {xp(locat)} + {refl}
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)}
zgilotynować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
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ładzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)} + {xp(mod)}
zgładzić: _: : perf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,sg,'pomoc',ratr)}
zgładzić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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łodnieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
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)}
zgnębić: _: : perf: subj{cp(int)} + {np(str)}
zgnębić: _: : perf: subj{cp(że)} + {np(str)}
zgnębić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zgnębić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zgnębić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
zgnoić się: _: : perf: subj{np(str)}
zgnoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zgnoić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zgnuśnieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zgnuśnieć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zgnuśnieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
zgonić się: _: : perf: subj{np(str)}
zgonić się: _: : perf: subj{np(str)} + {xp(locat)}
zgonić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zgonić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zgonić: _: : perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zgorszyć się: _: : perf: subj{np(str)} + {cp(int)}
zgorszyć się: _: : perf: subj{np(str)} + {cp(że)}
zgorszyć się: _: : perf: subj{np(str)} + {np(inst); prepnp(na,acc); ncp(inst,int); ncp(inst,że)}
zgorszyć się: _: : perf: subj{np(str)} + {or}
zgorszyć: _: : perf: subj{cp(int)} + {np(str)}
zgorszyć: _: : perf: subj{cp(że)} + {np(str)}
zgorszyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zgorszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zgorzknieć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',atr)}
zgorzknieć: _: : perf: subj{np(str)} + {preplexnp(na,acc,sg,'skutek',atr)}
zgorzknieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zgorzknieć: _: : perf: subj{np(str)} + {prepnp(wskutek,gen)}
zgorzknieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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}
zgrubieć: _: : perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zgrubieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zgrubieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zgrubieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen)}
zgrubieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zgrubieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgrubieć: _: : perf: subj{np(str)} + {np(dat)} + {xp(mod)}
zgruchotać: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgruchotać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zgruchotać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zgrupować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zgrupować się: _: : perf: subj{np(str)} + {xp(locat)}
zgrupować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zgrupować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgrywać się: _: : imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
zgrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zgrywać się: _: : imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
zgrywać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zgrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zgrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zgrywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zgrywać: _: : imperf: subj{np(str)} + {np(str)}
zgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(od,gen)}
zgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
zgrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zgryzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zgryźć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zgrzać się: _: : perf: subj{np(str)} + {np(dat)}
zgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zgrzać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
zgrzewać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
zgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zgrzewać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgrzybieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
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)}
zhańbić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zhańbić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zhańbić: _: : perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
zharmonizować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zharmonizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zhierarchizować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zidiocieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zidiocieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
zielenieć: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zielenieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zielenieć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zielenieć: _: : imperf: subj{np(str)} + {xp(locat)}
ziewać: _: : imperf: subj{np(str)}
ziewnąć: _: : perf: subj{np(str)}
ziębić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ziębić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ziębnąć: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
ziębnąć: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zignorować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
zilustrować: _: : perf: subj{np(str)} + {cp(int); cp(że)}
zilustrować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zimować: _: : imperf: subj{np(str)} + {xp(locat)}
zindywidualizować się: _: : perf: subj{np(str)}
zindywidualizować: _: : perf: subj{np(str)} + obj{np(str)}
zinstytucjonalizować się: _: : perf: subj{np(str)}
zinstytucjonalizować: _: : 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)}
ziszczać się: _: : imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
ziszczać: _: : imperf: subj{np(str)} + obj{np(str)}
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ździć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zjeździć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zjeździć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
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)}
zjeżyć się: _: : perf: subj{lexnp(str,_,'włos',atr)} + {np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)} + {preplexnp(na,loc,sg,'głowa',atr)}
zjeżyć się: _: : perf: subj{lexnp(str,_,'włos',atr)} + {np(dat)} + {preplexnp(na,acc,sg,'widok',natr)} + {preplexnp(na,loc,sg,'głowa',atr)}
zjeżyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zjeżyć się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zjeżyć się: _: : perf: subj{np(str)} + {np(inst)}
zjeżyć się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zjeżyć się: _: : perf: subj{np(str)} + {prepnp(przeciw,dat)}
zjeżyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zlaicyzować się: _: : perf: subj{np(str)}
zlaicyzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zleźć się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zleźć się: _: : perf: subj{np(str)} + {xp(locat)}
zleźć: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zleźć: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zliberalizować się: _: : perf: subj{np(str)}
zliberalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zlicytować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,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)}
zlinczować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
zlizać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zlizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zlizywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zlodowacieć: _: : perf: subj{np(str)} + {np(dat)}
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}
zluzować się: _: : perf: subj{np(str)} + {np(dat)}
zluzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zluzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zluzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zluzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zluzować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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łazić się: _: : imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
złazić się: _: : imperf: subj{np(str)} + {xp(locat)}
złazić: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
złazić: _: : imperf: subj{np(str)} + obj{np(str)}
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łomować: _: : imperf: subj{np(str)} + obj{np(str)}
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łowić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
złowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
złowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
złowić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
złupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
złupić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
złupić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
złupić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
złuszczać się: _: : imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)} + {xp(abl)}
złuszczać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(abl)} + {xp(locat)}
złuszczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
złuszczyć się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)} + {xp(abl)}
złuszczyć się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(abl)} + {xp(locat)}
złuszczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zmachać się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zmachać się: _: : perf: subj{np(str)} + {prepnp(przy,loc)}
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)}
zmagazynować się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zmagazynować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zmagazynować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zmajstrować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
zmajstrować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zmajstrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmajstrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zmajstrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zmajstrować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(mod)}
zmaksymalizować: _: : perf: subj{np(str)} + obj{np(str)}
zmaleć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmaltretować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmanierować się: _: : perf: subj{np(str)}
zmanierować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zmarginalizować się: _: : perf: subj{np(str)} + {prepnp(do,gen)}
zmarginalizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zmarkotnieć: _: : perf: subj{np(str)}
zmarnieć: _: : perf: subj{np(str)} + {np(dat)}
zmarnieć: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
zmarnieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zmarnieć: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zmarnieć: _: : perf: subj{np(str)} + {xp(locat)}
zmarnieć: _: : perf: subj{np(str)} + {xp(mod)}
zmarnieć: _: : perf: subj{np(str)} + {xp(temp)}
zmarnotrawić się: _: : perf: subj{np(str)}
zmarnotrawić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmarnotrawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zmarnotrawić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,żeby)}
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)}
zmartwić się: _: : perf: subj{np(str)} + {comprepnp(z powodu)}
zmartwić się: _: : perf: subj{np(str)} + {cp(int)}
zmartwić się: _: : perf: subj{np(str)} + {cp(że)}
zmartwić się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zmartwić się: _: : perf: subj{np(str)} + {or}
zmartwić się: _: : perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zmartwić: _: : perf: subj{cp(gdy)} + {np(str)}
zmartwić: _: : perf: subj{cp(int)} + {np(str)}
zmartwić: _: : perf: subj{cp(jak)} + {np(str)}
zmartwić: _: : perf: subj{cp(kiedy)} + {np(str)}
zmartwić: _: : perf: subj{cp(że)} + {np(str)}
zmartwić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zmartwić: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zmartwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zmartwieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
zmaterializować się: _: : perf: subj{np(str)} + {xp(locat)}
zmatowieć: _: : perf: subj{np(str)}
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)}
zmazać się: _: : perf: subj{np(str)} + {np(inst)}
zmazać się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zmazać się: _: : perf: subj{np(str)} + {xp(abl)}
zmazać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmazać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zmazać: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zmącić się: _: : perf: {np(dat)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(w,loc)}
zmącić się: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
zmącić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(w,loc)}
zmącić: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(dat)}
zmącić: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zmądrzeć: _: : perf: subj{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)}
zmiarkować się: _: : perf: subj{np(str)} + {comprepnp(co do)}
zmiarkować się: _: : perf: subj{np(str)} + {comprepnp(w kwestii)}
zmiarkować się: _: : perf: subj{np(str)} + {comprepnp(w sprawie)}
zmiarkować się: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
zmiarkować się: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
zmiarkować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
zmiarkować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
zmiarkować: _: : perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(ż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)}
zmielić się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(w,loc)}
zmielić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)} + {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)}
zmierzwić się: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zmierzwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zmierzwić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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ękczać się: _: : imperf: subj{np(str)}
zmiękczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmiękczyć się: _: : perf: subj{np(str)}
zmiękczyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zmitygować się: _: : perf: subj{np(str)} + {cp(że)}
zmitygować się: _: : perf: subj{np(str)} + {or}
zmitygować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zmitygować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zmizernieć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
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)}
zmonopolizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmontować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zmontować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zmordować się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zmordować: _: : perf: subj{np(str)} + {np(str)}
zmordować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmorzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmotoryzować się: _: : perf: subj{np(str)}
zmotoryzować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zmrużyć się: _: : perf: subj{np(str)}
zmrużyć: _: : perf: subj{np(str)} + obj{np(str)}
zmumifikować się: _: : perf: subj{np(str)}
zmumifikować: _: : perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
zmumifikować: _: : perf: subj{np(str)} + obj{np(str)} + {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)}
zmutować się: _: : perf: subj{np(str)} + {prepadjp(w,acc)}
zmutować się: _: : perf: subj{np(str)} + {prepnp(na,acc)}
zmutować się: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zmutować się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zmutować się: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zmutować: _: : perf: subj{np(str)} + obj{np(str)}
zmutować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zmutować: _: : perf: subj{np(str)} + {prepadjp(w,acc)}
zmutować: _: : perf: subj{np(str)} + {prepnp(u,gen)}
zmutować: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zmutować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
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)}
zmykać: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zmykać: _: : imperf: subj{np(str)} + {prepnp(przed,inst)}
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)}
znajdywać się: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
znajdywać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)}
znajdywać się: _: : imperf: subj{np(str)} + {xp(locat)}
znajdywać: _: : imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
znajdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
znajdywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znajdywać: _: : 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)}
zniemczyć się: _: : perf: subj{np(str)}
zniemczyć: _: : perf: subj{np(str)} + obj{np(str)}
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}
znieruchomieć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
znieruchomieć: _: : perf: subj{np(str)} + {prepnp(na,acc)}
znieruchomieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
znieruchomieć: _: : perf: subj{np(str)} + {xp(dur)}
znieruchomieć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
zniesmaczyć się: _: : perf: subj{np(str)} + {cp(int)}
zniesmaczyć się: _: : perf: subj{np(str)} + {cp(że)}
zniesmaczyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zniesmaczyć się: _: : perf: subj{np(str)} + {or}
zniesmaczyć: _: : perf: subj{cp(gdy)} + {np(str)}
zniesmaczyć: _: : perf: subj{cp(int)} + {np(str)}
zniesmaczyć: _: : perf: subj{cp(jak)} + {np(str)}
zniesmaczyć: _: : perf: subj{cp(kiedy)} + {np(str)}
zniesmaczyć: _: : perf: subj{cp(że)} + {np(str)}
zniesmaczyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
zniesmaczyć: _: : perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
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)}
zniewalać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
znieważać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
znieważyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zniewolić: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
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żkować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
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)}
znokautować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
znormalizować się: _: : perf: subj{np(str)} + {np(dat)}
znormalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
znużyć się: _: : perf: subj{np(str)} + {np(inst); ncp(inst,że)}
znużyć: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
znużyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); 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}
zobiektywizować się: _: : perf: subj{np(str)}
zobiektywizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zoczyć: _: : perf: subj{np(str)} + {cp(int)}
zoczyć: _: : perf: subj{np(str)} + {cp(jak)}
zoczyć: _: : perf: subj{np(str)} + {cp(że)}
zoczyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
zogniskować się: _: : perf: subj{np(str)} + {prepnp(na,loc)}
zogniskować się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zogniskować się: _: : perf: subj{np(str)} + {xp(locat)}
zogniskować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zogniskować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zogniskować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zohydzać się: _: : imperf: subj{np(str)} + {np(dat)}
zohydzać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zohydzić się: _: : perf: subj{np(str)} + {np(dat)}
zohydzić: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zoperować się: _: : perf: subj{np(str)} + {xp(locat)}
zoperować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zoperować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zoptymalizować się: _: : perf: subj{np(str)}
zoptymalizować: _: : perf: subj{np(str)} + obj{np(str)}
zorać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(pod,acc)}
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)}
zostawać się: _: : imperf: subj{np(str)} + {prepnp(po,loc)}
zostawać się: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
zostawać: _: : imperf: controller{np(dat)} + controllee{infp(_)}
zostawać: _: : imperf: subj,controller{np(str)} + controllee{adjp(pred)}
zostawać: _: : imperf: subj,controller{np(str)} + controllee{np(inst)}
zostawać: _: : imperf: subj{ncp(str,że)} + {np(dat)}
zostawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
zostawać: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
zostawać: _: : imperf: subj{np(str)} + {prepnp(bez,gen)}
zostawać: _: : imperf: subj{np(str)} + {prepnp(na,loc)}
zostawać: _: : imperf: subj{np(str)} + {prepnp(przy,loc)}
zostawać: _: : imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
zostawać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
zracjonalizować się: _: : perf: subj{np(str)}
zracjonalizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zradykalizować się: _: : perf: subj{np(str)}
zradykalizować: _: : perf: subj{np(str)} + obj{np(str)}
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)}
zrąbać się: _: : perf: subj{np(str)} + {np(dat)}
zrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrąbać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
zrecenzować: _: : perf: subj{np(str)} + {np(dat)} + {cp(że)}
zrecenzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zrecenzować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zrecenzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrecenzować: _: : perf: subj{np(str)} + obj{np(str)} + {or}
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)}
zreflektować się: _: : perf: subj{np(str)} + {cp(że)}
zreflektować się: _: : perf: subj{np(str)} + {or}
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)}
zrejterować się: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
zrejterować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zrejterować: _: : perf: subj{np(str)} + {prepnp(przed,inst)}
zrejterować: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
zrelatywizować się: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,int)}
zrelatywizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,int)}
zremisować: _: : perf: subj{np(str)} + obj{np(str)}
zremisować: _: : perf: subj{np(str)} + {prepnp(z,inst)}
zreorganizować się: _: : perf: subj{np(str)}
zreorganizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
zreorganizować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zreperować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zretuszować: _: : perf: subj{np(str)} + obj{np(str)}
zrewaloryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zrewaloryzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zrewolucjonizować się: _: : perf: subj{np(str)}
zrewolucjonizować: _: : perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zrewolucjonizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int)}
zrezygnować: _: : perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
zripostować: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zripostować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
zripostować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
zripostować: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
zripostować: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zrolować się: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zrolować się: _: : perf: subj{np(str)} + {prepnp(po,loc)}
zrolować się: _: : perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zrolować się: _: : perf: subj{np(str)} + {xp(locat)}
zrolować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zrolować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
zrugać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zrugać: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(od,gen)}
zrugać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zrugać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
zrugać: _: : perf: subj{np(str)} + {or} + {refl}
zrugać: _: : perf: subj{np(str)} + {prepadjp(od,gen)} + {refl}
zrugać: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
zrugać: _: : perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
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)}
zrumienić się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
zrumienić się: _: : perf: subj{np(str)} + {prepnp(na,loc)} + {xp(mod)}
zrumienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
zrumienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(mod)}
zrumienić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {advp(misc)}
zrusyfikować się: _: : perf: subj{np(str)}
zrusyfikować: _: : perf: subj{np(str)} + obj{np(str)}
zruszczyć się: _: : perf: subj{np(str)}
zruszczyć: _: : perf: subj{np(str)} + obj{np(str)}
zryczałtować: _: : perf: subj{np(str)} + obj{np(str)}
zryć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrywać się: _: : imperf: subj{np(str)} + {or}
zrywać się: _: : imperf: subj{np(str)} + {prepnp(do,gen)}
zrywać się: _: : imperf: subj{np(str)} + {prepnp(z,gen)}
zrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zrywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrywać: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
zrzeszyć się: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zrzeszyć się: _: : perf: subj{np(str)} + {prepnp(w,loc)}
zrzeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zrzeszyć: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zrzędzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(int)}
zrzędzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zrzędzić: _: : imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zrzędzić: _: : imperf: subj{np(str)} + {np(dat)} + {or}
zrzędzić: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
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)}
zsinieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepnp(z,gen)}
zsinieć: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
zsinieć: _: : perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
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)}
zsynchronizować się: _: : perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
zsynchronizować się: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zsynchronizować się: _: : perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zsynchronizować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
zsynchronizować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zsyntetyzować się: _: : perf: subj{np(str)}
zsyntetyzować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zsyntetyzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zsyntetyzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zsyntetyzować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zsyntetyzować: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zsypać się: _: : perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsypać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zsypywać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsypywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zszargać się: _: : perf: subj{np(str)}
zszargać: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
zszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zszyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zszywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,inst)}
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żeć: _: : perf: subj{np(str)} + {prepnp(o,acc)}
zubożyć: _: : perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zubożyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zunifikować się: _: : perf: subj{np(str)} + {advp(misc)}
zunifikować się: _: : perf: subj{np(str)} + {xp(locat)}
zunifikować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zurbanizować się: _: : perf: subj{np(str)}
zurbanizować: _: : perf: subj{np(str)} + obj{np(str)}
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żytkować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zużytkować: _: : perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zużytkować: _: : perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zużytkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zużytkować: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
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)}
zwarzyć się: _: : perf: subj{np(str)} + {np(dat)}
zwarzyć: _: : perf: subj{cp(gdy)} + {np(dat)} + {np(str)}
zwarzyć: _: : perf: subj{cp(int)} + {np(dat)} + {np(str)}
zwarzyć: _: : perf: subj{cp(jak)} + {np(dat)} + {np(str)}
zwarzyć: _: : perf: subj{cp(jeśli)} + {np(dat)} + {np(str)}
zwarzyć: _: : perf: subj{cp(kiedy)} + {np(dat)} + {np(str)}
zwarzyć: _: : perf: subj{cp(że)} + {np(dat)} + {np(str)}
zwarzyć: _: : perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(dat)} + {np(str)}
zwarzyć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zwarzyć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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ąchać: _: : perf: subj{np(str)} + {np(inst)} + {cp(że)}
zwąchać: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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)}
zwerbalizować: _: : perf: subj{np(str)} + {cp(int)}
zwerbalizować: _: : perf: subj{np(str)} + {cp(że)}
zwerbalizować: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
związywać się: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
związywać się: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
związywać: _: : imperf: subj,controller{np(str)} + controllee{xp(mod)} + {lexnp(str,sg,'koniec',natr)} + {preplexnp(z,inst,sg,'koniec',natr)}
związywać: _: : imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
związywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
związywać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
związywać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zwichnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
zwichrować się: _: : perf: subj{np(str)} + {np(dat)}
zwichrować: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zwidywać się: _: : imperf: subj{cp(że)} + {np(dat)}
zwidywać się: _: : imperf: subj{np(str)} + {np(dat)}
zwidzieć się: _: : perf: subj{cp(że)} + {np(dat)}
zwidzieć się: _: : perf: subj{np(str)} + {np(dat)}
zwiedzać: _: : imperf: subj{np(str)} + obj{np(str)}
zwiedzić: _: : perf: subj{np(str)} + obj{np(str)}
zwiedzieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(na temat)}
zwiedzieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
zwiedzieć się: _: : perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
zwiedzieć się: _: : perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen)}
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)}
zwierać się: _: : imperf: subj{np(str)} + {np(dat)}
zwierać się: _: : imperf: subj{np(str)} + {np(inst)}
zwierać się: _: : imperf: subj{np(str)} + {prepnp(w,acc)}
zwierać się: _: : imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zwierać się: _: : imperf: subj{np(str)} + {xp(locat)}
zwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zwierać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zwiesić się: _: : perf: subj{np(str)}
zwiesić się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zwiesić się: _: : perf: subj{np(str)} + {xp(adl)}
zwiesić się: _: : perf: subj{np(str)} + {xp(locat)}
zwiesić: _: : perf: subj{np(str)} + {lexnp(str,sg,'nos',natr)} + {preplexnp(na,acc,sg,'kwinta',natr)}
zwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwiesić: _: : perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zwieszać się: _: : imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zwieszać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zwieszać się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zwieszać: _: : imperf: subj{np(str)} + {lexnp(str,sg,'nos',natr)} + {preplexnp(na,acc,sg,'kwinta',natr)}
zwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwieszać: _: : imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
zwietrzeć: _: : perf: subj{np(str)}
zwietrzyć: _: : perf: subj{np(str)} + {cp(int)}
zwietrzyć: _: : perf: subj{np(str)} + {cp(że)}
zwietrzyć: _: : perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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ędnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepnp(z,gen)}
zwiędnąć: _: : perf: subj{np(str)} + {xp(locat)}
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)}
zwilgotnieć: _: : perf: subj{np(str)} + {np(dat)}
zwilgotnieć: _: : perf: subj{np(str)} + {np(inst)}
zwilgotnieć: _: : perf: subj{np(str)} + {prepnp(od,gen)}
zwilgotnieć: _: : perf: subj{np(str)} + {prepnp(z,gen)}
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)}
zwiotczać: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zwiotczać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zwiotczeć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
zwisnąć: _: : perf: subj,controller{np(str)} + controllee{xp(mod)}
zwisnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zwisnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zwisnąć: _: : perf: subj{np(str)} + {xp(abl)}
zwlec się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zwlec się: _: : perf: subj{np(str)} + {xp(abl)}
zwlec: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwlec: _: : perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
zwymyślać: _: : perf: subj{np(str)} + obj{np(str)} + {or}
zwymyślać: _: : perf: subj{np(str)} + obj{np(str)} + {prepadjp(od,gen)}
zwymyślać: _: : perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zwyrodnieć: _: : perf: subj{np(str)} + {advp(misc)}
zwyrodnieć: _: : perf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
zwyrodnieć: _: : perf: subj{np(str)} + {prepnp(w,acc)}
zwyżkować: _: : imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {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)}
zzielenieć: _: : perf: subj{np(str)} + {np(dat)} + {np(inst)}
zzielenieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zzielenieć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zziębnąć: _: : perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'kość',natr)}
zziębnąć: _: : perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zziębnąć: _: : perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zzuć się: _: : perf: subj{np(str)} + {prepnp(z,gen)}
zzuć: _: : perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zżąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zżywać się: _: : imperf: subj{np(str)} + {prepnp(z,inst)}
ż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)}
żarzyć się: _: : imperf: subj{np(str)} + {np(inst)}
żarzyć się: _: : imperf: subj{np(str)} + {xp(mod)}
żąć: _: : 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)}
żądlić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
żądlić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
ż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)}
żenować się: _: : imperf: subj,controller{np(str)} + controllee{infp(_)}
żenować: _: : imperf: subj{cp(gdy)} + {np(str)}
żenować: _: : imperf: subj{cp(int)} + {np(str)}
żenować: _: : imperf: subj{cp(jak)} + {np(str)}
żenować: _: : imperf: subj{cp(jeśli)} + {np(str)}
żenować: _: : imperf: subj{cp(kiedy)} + {np(str)}
żenować: _: : imperf: subj{cp(że)} + {np(str)}
żenować: _: : 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)}
żenować: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
żerować: _: : imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
żerować: _: : imperf: subj{np(str)} + {xp(locat)}
żgać: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
żgnąć: _: : perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
żłobić się: _: : imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
żłobić: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
żłopać: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ż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)}
żreć: _: : imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
żreć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
żreć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
żreć: _: : imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
żreć: _: : imperf: subj{np(str)} + {prepnp(za,acc)}
żuć: _: : imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
żwirować: _: : imperf: subj{np(str)} + obj{np(str)}
ż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)}
