
% The Polish Valence Dictionary (Walenty)
% March 04, 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, clarin2, clarin3, clarin4, clarin5, clarin6, clarin7, clarin8, clarin9, clarin_diff, czas_czasu, czas_emotywne, czas_mentalne, czas_misc1, czas_misc2, czas_misc3, czas_mowienia, czas_operacji, czas_percepcji, czas_percepcji2, czas_przemieszczenia, frek1, frek10, frek2, frek3, frek4, frek5, frek6, frek7, frek8, frek9
%     Frame opinions: pewna, wątpliwa, archaiczna, potoczna, wulgarna
%     Lemma statuses: tymczasowy, sprawdzone
%     Owners:         AnnaG, FilipS, JakubS, JoannaF, MaciejZ, MarcinO, MartaK, PaulinaR, PiotrB, SebasZ
%     Realizations:   None
%     Opinions added: False
%     
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)}
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)}
adaptować się: _: _: subj{np(str)} + {prepnp(do,gen)}
adaptować się: _: _: subj{np(str)} + {xp(locat)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
adresować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
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{np(str); ncp(str,int); ncp(str,że)}
akceptować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
aklimatyzować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
aklimatyzować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
aklimatyzować się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
aklimatyzować się: _: imperf: subj{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)} + {comprepnp(w czasie)}
akompaniować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(podczas,gen)}
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ć: _: _: 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)}
akredytować się: _: _: subj{np(str)} + {prepnp(na,acc)}
akredytować się: _: _: subj{np(str)} + {prepnp(przy,loc)}
akredytować się: _: _: subj{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}
amortyzować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
amortyzować się: _: imperf: subj{np(str)} + {np(dat)}
analizować: _: imperf: subj{np(str)} + obj{cp(int)}
analizować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
angażować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
angażować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
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)}
anonimizować: _: imperf: subj{np(str)} + obj{np(str)}
anulować: _: perf: subj{np(str)} + {ncp(str,że)}
anulować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
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)}
archaizować: _: imperf: subj{np(str)} + obj{np(str)}
archaizować się: _: imperf: subj{np(str)}
aresztować: _: _: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
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)}
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}
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)}
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ć: _: 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}
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)}
bagatelizować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,ż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)}
bandażować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
bankrutować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
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)}
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)}
bazować: _: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
beatyfikować: _: _: subj{np(str)} + obj{np(str)}
bełkotać: _: imperf: subj{np(str)} + {cp(że)} + {preplexnp(pod,inst,_,'nos',natr)}
bełkotać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
bełkotać: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)} + {or}
bełkotać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
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}
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)}
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)}
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)}
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)}
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)}
blokować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
blokować się: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
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łą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)} + {prepnp(w,loc)}
błąkać się: _: imperf: subj{np(str)} + {prepnp(wokół,gen)}
błąkać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
błąkać się: _: imperf: subj{np(str)} + {xp(perl)}
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,ż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,że)}
błogosławić: _: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {refl}
błyszczeć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
błyszczeć się: _: 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)}
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)}
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)}
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)}
boksować się: _: 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(że)} + {np(str)}
boleć: _: imperf: subj{lexnp(str,sg,'głowa',natr)} + {np(str)} + {prepncp(o,acc,int)}
boleć: _: imperf: subj{lexnp(str,sg,'głowa',natr)} + {np(str)} + {prepncp(o,acc,żeby)}
boleć: _: imperf: subj{lexnp(str,sg,'głowa',natr)} + {np(str)} + {prepnp(o,acc)}
boleć: _: imperf: subj{ncp(str,int)} + {np(str)}
boleć: _: imperf: subj{ncp(str,kiedy)} + {np(str)}
boleć: _: imperf: subj{np(str)} + {cp(że)}
boleć: _: imperf: subj{np(str); ncp(str,że)} + {np(str)}
boleć: _: imperf: subj{np(str)} + {np(str)} + {cp(że)}
boleć: _: imperf: subj{np(str)} + {or}
boleć: _: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,ż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)}
bootować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
bootować się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
borykać się: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
bożyć się: _: imperf: subj{np(str)} + {cp(że)}
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)}
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)}
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)} + {lexnp(gen,pl,'słowo',atr)}
brak: _: imperf: {np(dat)} + {prepnp(na,acc)} + {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)} + {lexnp(gen,pl,'słowo',atr)}
braknąć: _: imperf: {np(dat)} + {prepnp(na,acc)} + {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)}
bratać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
bratać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {np(str)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {or}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
bredzić: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
brnąć: _: imperf: subj{np(str)} + {cp(że)}
brnąć: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
brnąć: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
brnąć: _: imperf: subj{np(str)} + {prepnp(przez,acc)}
brnąć: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
brnąć: _: imperf: subj{np(str)} + {prepnp(za,inst)}
broczyć: _: 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)}
broczyć się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
broić: _: imperf: subj{np(str)} + {nonch}
bronić: _: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
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,że)}
bronić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że)}
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)}
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)}
brudzić się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
brudzić się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
brzmieć: _: imperf: controller{np(dat)} + controllee{xp(mod)} + {preplexnp(w,loc,pl,'ucho',natr)}
brzmieć: _: imperf: subj,controller{np(str)} + controllee{np(nom)}
brzmieć: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'usta',ratr)}
brzmieć: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',ratr)}
brzmieć: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(dla,gen)}
brzmieć: _: imperf: subj,controller{np(str); ncp(str,że)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',ratr)}
brzmieć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(w,loc,pl,'ucho',ratr)}
brzmieć: _: imperf: subj{np(str)} + {prepnp(w,loc)}
brzydzić: _: 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)}
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)}
buchać: _: imperf: {np(inst)} + {prepnp(od,gen)}
buchać: _: imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
buchać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
buchnąć: _: perf: {np(inst)} + {prepnp(od,gen)}
buchnąć: _: perf: {np(inst)} + {xp(abl)} + {xp(adl)}
buchnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
buchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
buchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
buchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
budować: _: 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)}
budować się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
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)}
buntować: _: imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
buntować: _: imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
buntować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
buntować się: _: imperf: subj{np(str)} + {prepncp(przeciw,dat,żeby)}
buntować się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
buntować się: _: imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {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)}
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)}
burzyć się: _: imperf: subj{np(str)} + {or}
burzyć się: _: imperf: subj{np(str)} + {prepnp(o,acc); 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)}
buszować: _: imperf: subj{np(str)} + {prepnp(po,loc); xp(locat)}
butwieć: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
butwieć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
butwieć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
butwieć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
butwieć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
być: _: imperf: controller{np(dat)} + controllee{infp(_)} + {advp(misc)}
być: _: imperf: {np(dat)} + {cp(że)} + {advp(misc)}
być: _: imperf: {prepnp(z,inst)} + {advp(misc)}
być: _: imperf: subj,controller{cp(gdy)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(gdy)} + controllee{np(inst)}
być: _: imperf: subj,controller{cp(int)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(int)} + controllee{np(inst)}
być: _: imperf: subj,controller{cp(jak)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(jak)} + controllee{np(inst)}
być: _: imperf: subj,controller{cp(jakoby)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(jakoby)} + controllee{np(inst)}
być: _: imperf: subj,controller{cp(jeśli)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(jeśli)} + controllee{np(inst)}
być: _: imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(kiedy)} + controllee{np(inst)}
być: _: imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(żeby)} + controllee{np(inst)}
być: _: imperf: subj,controller{cp(że)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{cp(że)} + controllee{np(inst)}
być: _: imperf: subj,controller{infp(_)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{infp(_)} + controllee{np(inst)}
być: _: imperf: subj,controller{lexnp(str,_,'powód',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{lexnp(str,sg,'okazja',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{lexnp(str,sg,'pomysł',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{lexnp(str,sg,'potrzeba',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{lexnp(str,sg,'rozkaz',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{lexnp(str,sg,'sens',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{lexnp(str,sg,'sposób',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{lexnp(str,_,'szansa',atr)} + controllee{infp(_)}
być: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
być: _: imperf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(w,loc,sg,'stan',natr)}
być: _: imperf: subj,controller{np(str)} + controllee{np(nom)}
być: _: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jakoby); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
być: _: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jakoby); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
być: _: imperf: subj{np(str)} + {lexnp(gen,sg,'zdanie',atr)}
być: _: imperf: subj{np(str)} + {prepnp(na,loc)}
być: _: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)}
być: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
być: _: imperf: subj{np(str)} + {prepnp(w,loc)}
być: _: imperf: subj{np(str)} + {prepnp(z,inst)}
być: _: imperf: subj{np(str)} + {xp(locat)}
być: _: imperf: subj{np(str)} + {xp(temp)}
bywać: _: imperf: controller{np(dat)} + controllee{infp(_)} + {advp(misc)}
bywać: _: imperf: {np(dat)} + {cp(że)} + {advp(misc)}
bywać: _: imperf: {prepnp(z,inst)} + {advp(misc)}
bywać: _: imperf: subj,controller{cp(gdy)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{cp(gdy)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{cp(int)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{cp(int)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{cp(jak)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{cp(jak)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{cp(jeśli)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{cp(jeśli)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{cp(kiedy)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{cp(żeby)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{cp(że)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{cp(że)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{infp(_)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{infp(_)} + controllee{np(inst)}
bywać: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
bywać: _: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
bywać: _: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
bywać: _: imperf: subj{np(str)} + {lexnp(gen,sg,'zdanie',atr)}
bywać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
bywać: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
bywać: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {xp(temp)}
bywać: _: imperf: subj{np(str)} + {prepnp(w,loc)}
bywać: _: imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
całować: _: 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ł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)}
cechować: _: imperf: subj{cp(że)} + {np(str)}
cechować: _: imperf: subj{np(str)} + {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)}
cechować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
cedzić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {or}
cedzić: _: imperf: subj{np(str)} + {prepnp(przez,acc)} + {cp(że)}
cedzić się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,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)}
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)}
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)}
charakteryzować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
charchać: _: imperf: subj{np(str)}
chcieć: _: imperf: controller{np(str)} + controllee{cp(żeby); infp(_); advp(misc)}
chcieć: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
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)}
chcieć się: _: imperf: controller{np(dat)} + controllee{infp(_)}
chcieć się: _: imperf: {np(dat)} + {np(gen)}
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}
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)}
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)}
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)}
chlapać się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
chlubić się: _: imperf: subj{np(str)} + {cp(że)}
chlubić się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
chlubić się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
chlupać: _: imperf: {np(dat)} + {xp(locat)}
chlupać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
chlupać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chlupać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
chlupać: _: imperf: subj{np(str)} + {prepnp(o,acc)}
chlupać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
chlupnąć: _: perf: {np(dat)} + {xp(locat)}
chlupnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
chlupnąć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
chlupnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
chlupnąć: _: perf: subj{np(str)} + {prepnp(o,acc)}
chlupnąć: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
chłeptać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
chłonąć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
chłonąć: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(perl)}
chodzić: _: imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
chodzić: _: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
chodzić: _: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
chodzić: _: imperf: subj{cp(żeby)} + {prepnp(za,inst)}
chodzić: _: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
chodzić: _: imperf: subj{cp(że)} + {prepnp(za,inst)}
chodzić: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
chodzić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chodzić: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
chodzić: _: imperf: subj{np(str)} + {prepnp(koło,gen)}
chodzić: _: imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
chodzić: _: imperf: subj{np(str)} + {prepnp(na,loc)}
chodzić: _: imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
chodzić: _: imperf: subj{np(str)} + {prepnp(w,loc)}
chodzić: _: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
chodzić: _: imperf: subj{np(str)} + {prepnp(z,inst)}
chodzić: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'łóżka',natr)}
chodzić: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'para',atr)}
chodzić: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
chorować: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
chorować: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
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}
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)}
chrapać: _: imperf: subj{np(str)}
chronić: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
chronić: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {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)} + {prepnp(od,gen)} + {xp(locat)}
chronić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
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)}
chrupać: _: imperf: {np(dat)} + {xp(locat)}
chrupać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
chrupać: _: imperf: subj{np(str)} + {np(inst)}
chrupać: _: imperf: subj{np(str)} + obj{np(str)}
chrupnąć: _: perf: {np(dat)} + {xp(locat)}
chrupnąć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
chrupnąć: _: perf: subj{np(str)} + {np(inst)}
chrupnąć: _: perf: subj{np(str)} + obj{np(str)}
chrzanić: _: 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)}
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)}
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)}
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,ż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,ż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)}
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}
chwycić się: _: perf: subj{np(str)} + {np(gen)}
chwycić się: _: perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
chwytać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
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)}
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)}
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ąć: _: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ciąć się: _: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
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ą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ąż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ć: _: imperf: subj{cp(że)} + {np(str)}
ciekawić: _: imperf: subj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(str)}
ciekawić się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ciemiężyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cierpieć: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
cierpieć: _: imperf: subj{np(str)} + {comprepnp(z powodu)}
cierpieć: _: imperf: subj{np(str)} + {cp(gdy)}
cierpieć: _: imperf: subj{np(str)} + {cp(jak)}
cierpieć: _: imperf: subj{np(str)} + {cp(jeśli)}
cierpieć: _: imperf: subj{np(str)} + {cp(żeby2)}
cierpieć: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
cieszyć: _: imperf: subj{cp(że)} + {np(str)}
cieszyć: _: imperf: subj{np(str); ncp(str,że)} + {np(str)}
cieszyć: _: imperf: subj{np(str)} + {np(inst)} + {np(str)}
cieszyć się: _: imperf: subj{np(str)} + {cp(że)}
cieszyć się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
cieszyć się: _: imperf: subj{np(str)} + {or}
cieszyć się: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
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)}
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)}
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ąć 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ąć się: _: perf: subj{np(str)} + {xp(adl)}
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)}
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)}
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)}
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)}
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)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
cucić się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
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)}
cyklinować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cytować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)} + {or}
cytować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
cywilizować: _: imperf: subj{np(str)} + obj{np(str)}
cywilizować się: _: imperf: subj{np(str)}
cyzelować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
czaić: _: imperf: subj{np(str)} + {cp(int)}
czaić: _: imperf: subj{np(str)} + {cp(że)}
czaić: _: imperf: subj{np(str)} + {np(str); ncp(str,że)}
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)}
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)}
czas: _: imperf: {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,ż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ć: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
czepiać się: _: imperf: subj{np(str)} + {np(gen)} + {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,inst)}
czernić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
czernić się: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
czerpać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepnp(z,gen); prepncp(z,gen,że)}
czerpać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
czerwienić: _: imperf: subj{np(str)} + obj{np(str)}
czerwienić się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
czerwienić się: _: imperf: subj{np(str)} + {np(inst)}
czesać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {refl}
czesać: _: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
czesać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
czesać się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
czesać się: _: imperf: subj{np(str)} + {xp(locat)}
częstować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
częstować się: _: imperf: subj{np(str)} + {np(inst)}
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(na,loc)}
czuć: _: imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
czuć: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,pl,'mięta',natr)}
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)}
czulić się: _: imperf: subj{np(str)} + {prepnp(do,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ć: _: 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)}
czynić się: _: imperf: {advp(misc)}
czynić się: _: imperf: subj,controller{np(str)} + controllee{adjp(pred)}
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}
czyścić się: _: imperf: subj{np(str)}
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)}
ćwiartować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
ć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)}
ćwiczyć się: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
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)}
dać się: _: perf: {infp(_)}
dać się: _: perf: subj{np(str)} + {np(dat)}
darować: _: _: subj{np(str)} + {np(dat)} + {cp(że)}
darować: _: _: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
darzyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
datować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
datować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
datować się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
datować się: _: imperf: subj{np(str)} + {xp(temp)}
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)}
dawać się: _: imperf: {infp(_)}
dawać się: _: imperf: subj{np(str)} + {np(dat)}
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)}
debiutować: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(inst)} + {prepnp(przed,inst)} + {xp(locat)}
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)}
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)}
dedykować: _: _: subj{np(str)} + obj{np(str)} + {np(dat); prepnp(dla,gen)}
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)}
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)}
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)}
dekorować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
delektować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
dementować: _: imperf: subj{np(str)} + {cp(jakoby)}
dementować: _: imperf: subj{np(str)} + {cp(że)}
dementować: _: imperf: subj{np(str)} + {cp(żeby)}
dementować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,jakoby); ncp(str,że); ncp(str,żeby)}
dementować: _: imperf: subj{np(str)} + {or}
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)}
denerwować: _: imperf: subj{cp(gdy)} + {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)}
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,że)}
denerwować się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
desantować: _: _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
desantować: _: _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(locat)}
desantować się: _: _: subj{np(str)} + {xp(abl)} + {xp(abl)}
desantować się: _: _: subj{np(str)} + {xp(abl)} + {xp(locat)}
dławić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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ł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)}
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)}
dmuchać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
dmuchnąć: _: perf: {np(inst)}
dmuchnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)} + {or}
dmuchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dmuchnąć: _: perf: subj{np(str)} + {prepnp(na,acc)}
dmuchnąć: _: perf: subj{np(str)} + {xp(adl)}
dobić: _: 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)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
dobić: _: perf: subj{np(str)} + obj{lexnp(gen,sg,'targ',natr)} + {prepnp(z,inst)}
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)}
dobić się: _: perf: subj{np(str)} + {np(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ć: _: 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)}
dobierać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobierać się: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
dobijać: _: imperf: subj{np(str)} + obj{lexnp(gen,sg,'targ',natr)} + {prepnp(z,inst)}
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)}
dobijać się: _: imperf: subj{np(str)} + {np(gen)}
dobijać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
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)}
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)}
dobrnąć: _: perf: subj{np(str)} + {prepnp(do,gen)}
dobrnąć: _: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
dobudować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dobudowywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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ć: _: imperf: subj{np(str)} + {cp(int)}
docenić: _: imperf: subj{np(str)} + {cp(że)}
docenić: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
docenić: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
docenić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
docenić: _: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
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)}
docierać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
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}
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}
dofinansować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dofinansować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
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)}
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)}
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)}
doganiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
doganiać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
doganiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
doglądać: _: imperf: subj{np(str)} + {cp(int)}
doglądać: _: imperf: subj{np(str)} + {cp(jak)}
doglądać: _: imperf: subj{np(str)} + obj{np(gen)}
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)}
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)}
dograć się: _: perf: 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)}
dogrywać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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(do,gen)}
dojechać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dojechać: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
dojechać: _: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
dojechać: _: perf: subj{np(str)} + obj{np(str)}
dojechać: _: perf: subj{np(str)} + {prepnp(na,loc)}
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)}
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)} + {prepnp(w,loc)}
dojrzeć: _: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dojrzeć: _: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
dokarmiać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
dokarmiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
dokarmić: _: perf: subj{np(str)} + {np(inst)} + {refl}
dokarmić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
dokazać: _: perf: subj{np(str)} + {cp(że)}
dokazać: _: perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dokazywać: _: imperf: subj{np(str)} + {cp(że)}
dokazywać: _: imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dokazywać: _: imperf: subj{np(str)} + {prepnp(z,inst)}
dokładać: _: 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)}
dokładać się: _: imperf: subj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dokonać: _: perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dokonać się: _: perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
dokonywać: _: imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dokonywać się: _: perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
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}
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ęcać się: _: imperf: 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)}
dokręcić się: _: perf: subj{np(str)} + {np(dat)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
doliczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
doliczyć: _: perf: subj{np(str)} + {prepnp(do,gen)}
doliczyć się: _: perf: subj{np(str)} + {np(gen)}
dołączać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dołączać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
dołączyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dołączyć się: _: perf: subj{np(str)} + {prepnp(do,gen)}
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)}
dołożyć się: _: perf: subj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
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)}
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)}
dominować: _: perf: subj{np(str)} + obj{np(str)}
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ś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ść: _: 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)} + {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)}
donieść się: _: perf: subj{cp(że)} + {prepnp(do,gen)}
donieść się: _: perf: subj{np(str)} + {xp(adl)}
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)} + {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)}
donosić: _: perf: subj{np(str)} + obj{np(str)}
donosić się: _: imperf: subj{np(str)} + {xp(abl)}
dookreślać: _: imperf: subj{np(str)} + {cp(że)}
dookreślać: _: imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
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ć: _: 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)}
dopadać się: _: perf: subj{np(str)} + {prepnp(do,gen)}
dopakowywać: _: imperf: subj{np(str)} + obj{np(str)}
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)}
dopasować się: _: perf: 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)}
dopasowywać się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
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)}
dopaść się: _: perf: subj{np(str)} + {prepnp(do,gen)}
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)}
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)}
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)}
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)}
dopełniać: _: imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dopełniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopełniać się: _: imperf: 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łnić się: _: perf: subj{np(str)}
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)}
dopisać: _: perf: subj{np(str)} + {cp(int)} + {xp(locat)}
dopisać: _: perf: subj{np(str)} + {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)}
dopisać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
dopisać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
dopisać się: _: perf: subj{np(str)} + {prepnp(do,gen)}
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)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dopracować się: _: perf: 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)}
dopracowywać się: _: imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dopraszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopraszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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}
doprosić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doprosić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
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}
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)}
dopuszczać się: _: imperf: 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)}
dopuścić się: _: perf: subj{np(str)} + {np(gen); ncp(gen,ż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)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
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)}
dorzucać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
dorzucać się: _: imperf: 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)}
dorzucić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
dorzucić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
dosiadać: _: imperf: subj{np(str)} + obj{np(gen)}
dosiadać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dosiadać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
dosiąść: _: perf: subj{np(str)} + {np(gen)}
dosiąść się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dosiąść się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
dosięgnąć: _: perf: subj{np(str)} + {np(gen)}
dosięgnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dosięgnąć: _: perf: subj{np(str)} + {np(str)} + {or}
dosięgnąć: _: perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dosięgnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
doskwierać: _: imperf: subj{cp(że)} + {np(dat)}
doskwierać: _: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
dosłać: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dosłuchać: _: perf: subj{np(str)} + obj{np(str)}
dosłuchać się: _: perf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
dosłuchiwać: _: imperf: subj{np(str)} + obj{np(gen)}
dosłuchiwać się: _: imperf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
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)}
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)}
dostać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostać się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dostarczać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
dostarczyć: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {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)}
dostawać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostawać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dostąpić: _: perf: subj{np(str)} + {np(gen); ncp(gen,że)}
dostąpić: _: perf: subj{np(str)} + {prepnp(do,gen)}
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)}
dostosować się: _: perf: 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)}
dostosowywać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostrzec: _: perf: subj{np(str)} + {cp(jak)}
dostrzec: _: perf: subj{np(str)} + {cp(żeby2)}
dostrzec: _: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzec: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dostrzegać: _: imperf: subj{np(str)} + {cp(jak)}
dostrzegać: _: imperf: subj{np(str)} + {cp(żeby2)}
dostrzegać: _: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzegać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dosyłać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
dość: _: _: {cp(żeby)} + {infp(_)}
dość: _: _: {np(gen)}
dośrodkować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dośrodkować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dośrodkować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doświadczać: _: imperf: subj{np(str)} + {cp(int)}
doświadczać: _: imperf: subj{np(str)} + {cp(że)}
doświadczać: _: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)} + {np(inst)}
doświadczyć: _: perf: subj{np(str)} + {cp(int)}
doświadczyć: _: perf: subj{np(str)} + {cp(że)}
doświadczyć: _: perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)} + {np(inst)}
dotańczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dotknąć: _: 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)}
dotknąć się: _: perf: subj{np(str)} + {np(gen)}
dotknąć się: _: perf: subj{np(str)} + {prepnp(do,gen)}
dotrwać: _: perf: subj{np(str)} + {cp(aż)}
dotrwać: _: perf: subj{np(str)} + {np(gen)}
dotrwać: _: perf: subj{np(str)} + {prepnp(do,gen)}
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)}
dotrzeć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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ć: _: 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)}
dotykać się: _: imperf: subj{np(str)} + {np(gen)}
dotykać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
dowiadywać się: _: imperf: subj{np(str)} + {np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(u,gen); prepnp(z,gen)}
dowiadywać się: _: imperf: subj{np(str)} + {np(gen)} + {prepnp(o,loc)} + {prepnp(od,gen)}
dowiadywać się: _: imperf: subj{np(str)} + {or}
dowiadywać się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(u,gen)}
dowiedzieć się: _: perf: subj{np(str)} + {np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(u,gen); prepnp(z,gen)}
dowiedzieć się: _: perf: subj{np(str)} + {np(gen)} + {prepnp(o,loc)} + {prepnp(od,gen)}
dowiedzieć się: _: perf: subj{np(str)} + {or}
dowiedzieć się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(u,gen)}
dowierzać: _: imperf: subj{np(str)} + {cp(żeby2)}
dowierzać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dowierzać: _: imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby2)}
dowieść: _: perf: subj{np(str); ncp(str,że)} + obj{np(gen); ncp(gen,że)} + {np(dat)} + {np(inst)}
dowieść: _: perf: subj{np(str)} + obj{cp(ż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)}
dowodzić: _: imperf: subj{ncp(str,że)} + obj{cp(że)}
dowodzić: _: imperf: subj{np(str); ncp(str,że)} + obj{np(gen); ncp(gen,że)} + {np(dat)} + {np(inst)}
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(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)}
doznać: _: perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)}
doznawać: _: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)}
dozorować: _: imperf: subj{np(str)} + {cp(int)}
dozorować: _: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int)}
dozorować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
dozować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
dożyć: _: perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dożyć: _: perf: subj{np(str)} + {np(str)}
dożyć: _: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dożywać: _: imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dożywać: _: imperf: subj{np(str)} + {np(str)}
dożywać: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dożywiać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
dożywiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dożywić: _: perf: subj{np(str)} + {np(inst)} + {refl}
dożywić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dramatyzować: _: imperf: subj{np(str)} + {cp(że)}
dramatyzować: _: imperf: subj{np(str)} + obj{np(str)}
dramatyzować: _: imperf: subj{np(str)} + {or}
drażnić: _: imperf: subj{cp(kiedy)} + {np(str)}
drażnić: _: imperf: subj{cp(że)} + {np(str)}
drażnić: _: imperf: subj{ncp(str,kiedy)} + {np(str)}
drażnić: _: imperf: subj{np(str); ncp(str,że)} + {np(str)}
drażnić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
drażnić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
dreptać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
dreptać: _: imperf: subj{np(str)} + {np(inst)}
dreptać: _: imperf: subj{np(str)} + {prepnp(koło,gen); prepncp(koło,gen,żeby)}
dreptać: _: imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,żeby)}
dreptać: _: imperf: subj{np(str)} + {prepnp(za,inst)}
dreptać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dreptać: _: imperf: subj{np(str)} + {xp(locat)}
dręczyć: _: imperf: subj{np(str)} + {cp(że)} + {refl}
dręczyć: _: imperf: subj{np(str)} + {ncp(inst,że)} + {refl}
dręczyć: _: imperf: subj{np(str)} + {np(inst)} + {refl}
dręczyć: _: imperf: subj{np(str)} + {np(str)} + {cp(że)}
dręczyć: _: imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
dręczyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
drgać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
drgać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
drgać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drgać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
drgać: _: imperf: subj{np(str)} + {np(inst)}
drgnąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
drgnąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
drgnąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drgnąć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
drgnąć: _: perf: subj{np(str)} + {np(inst)}
drobić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
drobić: _: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
drobić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
drobić: _: imperf: subj{np(str)} + {prepnp(za,inst)}
drobić: _: imperf: subj{np(str)} + {xp(perl)}
drożeć: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
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)}
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)}
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)}
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)}
drżeć: _: imperf: subj{np(str)} + {cp(czy)}
drżeć: _: imperf: subj{np(str)} + {cp(że)}
drżeć: _: imperf: subj{np(str)} + {cp(żeby)}
drżeć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
drżeć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drżeć: _: imperf: subj{np(str)} + {or}
drżeć: _: imperf: subj{np(str)} + {preplexnp(w,loc,pl,'posada',natr)}
drżeć: _: imperf: subj{np(str)} + {prepnp(do,gen)}
drżeć: _: imperf: subj{np(str)} + {prepnp(nad,inst)}
drżeć: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
drżeć: _: imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
dudnić: _: imperf: {np(dat)} + {xp(locat)}
dudnić: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dudnić: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
dudnić: _: imperf: subj{np(str)} + {np(inst)} + {or}
dudnić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
dudnić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dudnić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dudnić: _: imperf: subj{np(str)} + {prepnp(od,gen)}
dudnić: _: imperf: subj{or} + {np(dat)} + {xp(locat)}
dukać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
dukać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
dukać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
dukać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
dukać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
dukać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
dumać: _: 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)}
dusić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dusić: _: imperf: subj{np(str)} + obj{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)}
duszać: _: imperf: subj{np(str)} + {np(inst)}
dwoić: _: imperf: subj{np(str)} + obj{np(str)}
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)}
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)}
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)}
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)}
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)}
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)}
dysponować: _: imperf: subj{np(str)} + {np(inst)}
dysponować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dysponować: _: imperf: subj{np(str)} + {or}
dyszeć: _: imperf: subj{np(str)} + {fixed('ledwie')}
dyszeć: _: imperf: subj{np(str)} + {fixed('ledwo')}
dyszeć: _: imperf: subj{np(str)} + {np(inst)}
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)}
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)}
dziedziczyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
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)}
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)}
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ć: _: 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)}
dziobać się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
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)}
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}
dzwonić: _: imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
dzwonić: _: imperf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
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(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
dzwonić: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
dzwonić: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
dzwonić: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
dzwonić: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
dzwonić: _: imperf: subj{np(str)} + {prepnp(na,acc)}
dzwonić: _: imperf: subj{np(str)} + {prepnp(za,inst)}
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ź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ź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)}
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)}
egzaminować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
egzaminować: _: imperf: subj{np(str)} + obj{np(str)} + {or}
egzaminować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
egzekwować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
ekscytować: _: 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)}
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}
eksmitować: _: _: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
eksperymentować: _: imperf: subj{np(str)} + {np(inst)}
eksperymentować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
eksperymentować: _: imperf: subj{np(str)} + {prepnp(z,inst)}
eksploatować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
eksploatować: _: imperf: subj{np(str)} + {refl}
eksplodować: _: _: subj{np(str)} + {np(inst)}
eksplodować: _: _: subj{np(str)} + obj{np(str)}
eksponować: _: 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)}
eliminować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
emaliować: _: imperf: subj{np(str)} + obj{np(str)}
emanować: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
emanować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
emanować: _: imperf: subj{np(str)} + {prepnp(od,gen)}
emanować: _: imperf: subj{np(str)} + {prepnp(z,gen)}
emigrować: _: _: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
emitować: _: _: subj{np(str)} + obj{np(str)} + {xp(locat)}
estetyzować: _: imperf: subj{np(str)} + obj{np(str)}
ewakuować: _: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ewakuować się: _: _: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
falować: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
falować: _: imperf: subj{np(str)} + obj{np(str)}
fałszować: _: imperf: subj{np(str)} + {cp(że)}
fałszować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
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)}
fascynować: _: imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(str)}
fascynować: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
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)}
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)}
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)}
faulować: _: imperf: subj{np(str)} + obj{np(str)}
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)}
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)}
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)}
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)}
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)}
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)}
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ć: _: 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)}
forsować się: _: imperf: subj{np(str)} + {np(inst)}
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)}
fruwać: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
fruwać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
fundować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
fundować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
funkcjonować: _: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
funkcjonować: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
funkcjonować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
gadać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
gadać: _: imperf: subj{np(str)} + {np(dat)} + {np(str)}
gadać: _: imperf: subj{np(str)} + {np(dat)} + {or}
gadać: _: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
gadać: _: imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
gadać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
gadać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
gadać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
gadać: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
gadać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
gadać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
gadać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
gadać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
galopować: _: imperf: subj{np(str)} + {np(inst)}
galopować: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ganić: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
ganić: _: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
ganić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
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)}
gardzić: _: imperf: subj{np(str)} + {np(inst)}
garnąć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
garnąć: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
gasić: _: imperf: subj{np(str)} + {np(inst)} + {refl}
gasić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gasić: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'zarodek',natr)}
gasić się: _: imperf: subj{np(str)}
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)}
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)}
gestykulować: _: imperf: subj{np(str)} + {cp(że)}
gestykulować: _: imperf: subj{np(str)} + {np(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)}
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)}
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)}
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)} + obj{np(str)} + {np(dat)} + {np(inst)}
głaskać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
głodować: _: imperf: subj{np(str)}
głodzić: _: imperf: subj{np(str)} + obj{np(str)}
głodzić: _: imperf: subj{np(str)} + {refl}
głosić: _: imperf: subj{np(str)} + {ncp(str,że)}
głosić: _: imperf: subj{np(str)} + obj{np(str); cp(że)}
głosić: _: imperf: subj{np(str)} + {or}
głosić: _: imperf: subj{np(str)} + {prepncp(o,loc,int)}
głosić: _: imperf: subj{np(str)} + {prepncp(o,loc,jak)}
głosić: _: imperf: subj{np(str)} + {prepnp(o,loc); 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ł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łupieć: _: imperf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
głupieć: _: imperf: subj{np(str)} + {prepnp(dla,gen)}
głupieć: _: imperf: subj{np(str)} + {prepnp(od,gen)}
głupieć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
gmatwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
gmatwać się: _: imperf: subj{np(str)} + {np(dat)}
gmatwać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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ć: _: 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,że)}
gnębić się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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ść: _: 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)}
gnieść się: _: imperf: subj{np(str)} + {xp(locat)}
gniewać: _: imperf: subj{cp(że)} + {np(str)}
gniewać: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
gniewać się: _: imperf: subj{np(str)} + {comprepnp(z powodu)}
gniewać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
gniewać się: _: imperf: subj{np(str)} + {or}
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,że)}
gniewać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
gniewać się: _: imperf: subj{np(str)} + {prepnp(o,acc); 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,że)}
gnieździć się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
gnieździć się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
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)}
goić: _: imperf: subj{np(str)} + {np(str)}
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)}
golić: _: imperf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
golić: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
golić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
golić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
golić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
golić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
gonić: _: 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)}
gonić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
gorzeć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
gorzeć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
gospodarować: _: imperf: subj{np(str)} + {np(inst)}
gospodarować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
gospodarować: _: imperf: subj{np(str)} + {xp(locat)}
gościć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gościć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
gościć: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gotować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
gotować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
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)}
górować: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(nad,inst)}
grabić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {lexnp(dat,_,'siebie',natr)}
grabić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
grabić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(pod,acc,_,'siebie',natr)}
grabić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
grabić: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
grabić: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
grabić: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
grać: _: imperf: subj{np(str)} + {comprepnp(na rzecz)}
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)} + {np(dat)} + {prepnp(na,loc)}
grać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); prepnp(w,loc); xp(locat)}
grać: _: imperf: subj{np(str)} + {prepnp(do,gen)}
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)}
graniczyć: _: imperf: subj{np(str)} + {prepnp(z,inst)}
grasować: _: imperf: subj{np(str)} + {xp(locat)}
gratulować: _: imperf: subj{np(str)} + {np(dat)} + {np(gen); cp(że); ncp(gen,że)}
gromadzić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
gromadzić: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gromadzić się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
gromadzić się: _: imperf: subj{np(str)} + {xp(locat)}
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)} + {or}
grozić: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
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}
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)}
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)}
grzać się: _: imperf: subj{np(str)} + {np(inst)}
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)}
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ć: _: 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)}
grzmocić się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
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)}
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)}
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)}
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)}
gumować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gustować: _: imperf: subj{np(str)} + {prepnp(w,loc)}
gwałcić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
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ąć: _: 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)}
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)}
hamować: _: imperf: subj{np(str)} + {cp(żeby)} + {refl}
hamować: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
hamować: _: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
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)}
harmonizować: _: imperf: subj{np(str)} + {np(inst)}
harmonizować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
heblować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
histeryzować: _: imperf: subj{np(str)} + {comprepnp(z powodu)}
histeryzować: _: imperf: subj{np(str)} + {cp(że)}
histeryzować: _: imperf: subj{np(str)} + {np(inst)}
histeryzować: _: imperf: subj{np(str)} + {or}
histeryzować: _: imperf: subj{np(str)} + {prepnp(nad,inst)}
histeryzować: _: imperf: subj{np(str)} + {prepnp(o,loc)}
hodować: _: 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(w,loc)}
hodować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
hodować się: _: imperf: subj{np(str)} + {advp(misc)}
hołdować: _: imperf: subj{np(str)} + {np(dat)}
hołdować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
hołubić: _: imperf: subj{np(str)} + obj{np(str)}
honorować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
honorować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
huczeć: _: imperf: {np(dat)} + {xp(locat)}
huczeć: _: imperf: {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {xp(locat)}
huczeć: _: imperf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
huczeć: _: imperf: subj{cp(int)} + {xp(locat)}
huczeć: _: imperf: subj{cp(że)} + {xp(locat)}
huczeć: _: imperf: subj{np(str)} + {cp(int)}
huczeć: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
huczeć: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
huczeć: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
huczeć: _: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
huczeć: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
huknąć: _: 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}
huknąć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
huknąć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
humanizować się: _: imperf: subj{np(str)}
huśtać: _: imperf: subj{np(str)} + {np(inst)}
huśtać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
huśtać się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
idealizować: _: imperf: subj{np(str)} + obj{np(str)}
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)}
identyfikować się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,nom)}
identyfikować się: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
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)}
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)}
infekować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
informować: _: imperf: subj{np(str)} + {np(str)} + {or}
informować: _: imperf: subj{np(str)} + obj{np(str)} + {cp(jakoby)}
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)}
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)} + {prepnp(co do,gen)} + {prepnp(u,gen)}
informować się: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {prepnp(u,gen)}
informować się: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {xp(locat)}
informować się: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(int)}
ingerować: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc); prepncp(w,acc,int)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
inspirować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
inspirować się: _: imperf: subj{np(str)} + {np(inst)}
instalować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
instalować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
instalować się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
instalować się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
instruować się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
interesować: _: imperf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(str)}
interesować się: _: imperf: subj{np(str)} + {cp(int)}
interesować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
inwestować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ironizować: _: imperf: subj{np(str)} + {comprepnp(co do)}
ironizować: _: imperf: subj{np(str)} + {comprepnp(na temat)}
ironizować: _: imperf: subj{np(str)} + {comprepnp(w sprawie)}
ironizować: _: imperf: subj{np(str)} + {cp(że)}
ironizować: _: imperf: subj{np(str)} + {or}
ironizować: _: imperf: subj{np(str)} + {prepnp(o,loc)}
irytować: _: 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)}
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)}
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)}
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(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)}
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)}
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)}
jaśnieć: _: imperf: subj{E} + {xp(locat)}
jaśnieć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
jaśnieć: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
jawić się: _: imperf: subj,controller{np(str)} + controllee{adjp(str)} + {np(dat)}
jawić się: _: imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
jawić się: _: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
jawić się: _: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(przed,inst)}
jawić się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
jawić się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
jawić się: _: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
jawić się: _: imperf: subj{np(str)} + {xp(locat)}
jąć: _: perf: subj,controller{E} + controllee{infp(imperf)}
jąć się: _: perf: subj{np(str)} + {np(gen)}
jechać: _: imperf: {np(inst)} + {prepnp(od,gen)}
jechać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
jechać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
jechać: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
jechać: _: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
jechać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
jechać: _: imperf: subj{np(str)} + {prepnp(po,loc)}
jechać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {fixed('na jednym wózku')}
jednoczyć: _: 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)}
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)}
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(inst)} + {prepnp(do,gen)}
jeździć: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
jeździć: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
jeździć: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
jeździć: _: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
jeździć: _: imperf: subj{np(str)} + {prepnp(na,loc)}
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)}
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)}
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)}
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)}
kandydować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
kandydować: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
kanonizować: _: _: subj{np(str)} + obj{np(str)} + {np(inst)}
kaprysić: _: imperf: subj{np(str)} + {comprepnp(co do)}
kaprysić: _: imperf: subj{np(str)} + {comprepnp(na temat)}
kaprysić: _: imperf: subj{np(str)} + {comprepnp(z powodu)}
kaprysić: _: imperf: subj{np(str)} + {cp(że)}
kaprysić: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
kaprysić: _: imperf: subj{np(str)} + {prepnp(z,inst)}
karać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); 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)}
karmić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
karmić się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
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)}
kasować się: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kazić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
kąpać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kąpać: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
kąpać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
kibicować: _: imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
kibicować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
kibicować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kichać: _: imperf: subj{np(str)} + {np(inst)}
kichać: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
kichać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
kiełkować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kierować: _: imperf: subj{np(str)} + obj{np(inst)}
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(ku,dat)}
kierować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
kipieć: _: imperf: subj{E} + {prepnp(od,gen)} + {xp(locat)}
kipieć: _: imperf: subj{E} + {prepnp(w,loc)} + {prepnp(z,gen)}
kipieć: _: imperf: subj{np(str)} + {np(inst)}
kipieć: _: imperf: subj{np(str)} + {prepnp(od,gen)}
kipieć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
kipieć: _: imperf: subj{np(str)} + {xp(abl)}
kipieć: _: imperf: subj{np(str)} + {xp(adl)}
kiwać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
kiwać: _: imperf: subj{np(str)} + obj{np(str)}
kiwać się: _: imperf: subj{np(str)} + {prepnp(od,gen)}
kiwnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
kiwnąć: _: perf: subj{np(str)} + obj{np(str)}
kiwnąć się: _: perf: subj{np(str)}
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)}
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ąć się: _: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
kląć się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
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(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)} + obj{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
klepać: _: imperf: subj{np(str)} + obj{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(do,gen)}
klepać: _: imperf: subj{np(str)} + {or}
klepnąć: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
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); cp(żeby)} + {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)}
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)}
kluczyć: _: imperf: subj{np(str)} + {comprepnp(co do)}
kluczyć: _: imperf: subj{np(str)} + {comprepnp(na temat)}
kluczyć: _: imperf: subj{np(str)} + {comprepnp(w kwestii)}
kluczyć: _: imperf: subj{np(str)} + {comprepnp(w sprawie)}
kluczyć: _: imperf: subj{np(str)} + {cp(że)}
kluczyć: _: imperf: subj{np(str)} + {or}
kluczyć: _: imperf: subj{np(str)} + {prepnp(o,loc)}
kluczyć: _: imperf: subj{np(str)} + {prepnp(za,inst)}
kluczyć: _: imperf: subj{np(str)} + {xp(adl)}
kluczyć: _: imperf: subj{np(str)} + {xp(locat)}
kluczyć: _: imperf: subj{np(str)} + {xp(perl)}
kłamać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
kłamać: _: imperf: subj{np(str)} + {or}
kłamać: _: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
kłamać: _: imperf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
kłaniać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(od,gen)}
kłaniać się: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'pas',natr)}
kłaniać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
kłaść: _: imperf: subj{np(str)} + {lexnp(str,pl,'ucho',natr)} + {preplexnp(po,loc,_,'siebie',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{infp(imperf)}
kłaść: _: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {preplexnp(w,acc,pl,'ucho',natr)}
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łaść się: _: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
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łę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łócić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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łuć: _: imperf: {np(str)} + {xp(locat)}
kłuć: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
kłuć: _: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
kłuć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kłuć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kłusować: _: imperf: subj{np(str)} + {prepnp(na,acc)}
kłusować: _: imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
kneblować: _: imperf: subj{np(str)} + {np(inst)} + {refl}
kneblować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
knuć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
kochać: _: 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ć się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
kochać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
kocić: _: imperf: subj{np(str)} + obj{np(str)}
kocić się: _: imperf: subj{np(str)}
koczować: _: imperf: subj{np(str)} + {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)}
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)}
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)}
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)}
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}
kolekcjonować: _: imperf: subj{np(str)} + obj{np(str)}
kolidować: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
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ł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ł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)}
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)}
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}
komentować: _: imperf: subj{np(str)} + obj{np(str)} + {or}
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ć: _: 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)}
komplikować się: _: imperf: subj{np(str)} + {np(dat)}
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)}
komunikować się: _: 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)}
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)}
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)}
koncertować: _: imperf: subj{np(str)} + {xp(locat)}
koncesjonować: _: _: subj{np(str)} + obj{np(str)}
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)}
konstruować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
konsultować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
konsultować się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
kontaktować: _: imperf: subj{np(str)}
kontaktować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
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}
kontrolować: _: imperf: subj{np(str)} + {cp(int)} + {refl}
kontrolować: _: imperf: subj{np(str)} + {cp(że)}
kontrolować: _: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
kontrolować: _: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
kontrolować: _: imperf: subj{np(str)} + {refl}
kontuzjować: _: _: subj{np(str)} + obj{np(str)}
kontuzjować się: _: _: subj{np(str)}
kontynuować: _: imperf: subj{np(str)} + obj{np(str)} + {or}
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)}
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)}
koordynować: _: imperf: subj{np(str)} + {np(inst)}
koordynować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
kopać się: _: imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)}
kopać się: _: imperf: subj{np(str)} + {xp(adl)}
kopiować: _: imperf: subj{np(str)} + obj{np(str)} + {np(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)}
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)}
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)}
kosztować: _: imperf: subj{np(str)} + {np(str)} + {np(str)}
kosztować: _: imperf: subj{np(str)} + obj{np(part)}
kować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
kpić: _: imperf: subj{np(str)} + {prepncp(z,gen,że)}
kpić: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
kpić: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
krajać: _: 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)}
krajać się: _: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)}
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)}
kraść: _: imperf: subj{np(str)} + obj{np(str)} + {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)}
kredytować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kredytować się: _: imperf: subj{np(str)} + {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)}
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ę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ę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ępować się: _: imperf: subj{np(str)} + {cp(że)}
krępować się: _: imperf: subj{np(str)} + {infp(_)}
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)}
krochmalić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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ć: _: 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)}
kroić się: _: imperf: subj{np(str)} + {np(dat)}
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)}
królować: _: imperf: subj{np(str)} + {np(dat)}
królować: _: imperf: subj{np(str)} + {prepnp(nad,inst)}
królować: _: imperf: subj{np(str)} + {xp(locat)}
kruszyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kruszyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kruszyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kruszyć: _: imperf: subj{np(str)} + {prepncp(o,acc,int)} + {lexnp(str,_,'kopia',natr)}
kruszyć: _: imperf: subj{np(str)} + {prepncp(o,acc,żeby)} + {lexnp(str,_,'kopia',natr)}
kruszyć: _: imperf: subj{np(str)} + {prepncp(o,acc,że)} + {lexnp(str,_,'kopia',natr)}
kruszyć: _: imperf: subj{np(str)} + {prepnp(o,acc)} + {lexnp(str,_,'kopia',natr)}
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)}
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(gdy)}
krwawić: _: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(jak)}
krwawić: _: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(jeśli)}
krwawić: _: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(kiedy)}
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(gdy)}
krwawić: _: imperf: subj{lexnp(str,sg,'serce',ratr)} + {cp(jak)}
krwawić: _: imperf: subj{lexnp(str,sg,'serce',ratr)} + {cp(kiedy)}
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)}
krwawić się: _: imperf: subj{lexnp(str,sg,'serce',natr)} + {cp(jak)}
krwawić się: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'serce',natr)}
krwawić się: _: imperf: subj{np(str)} + {np(inst)}
kryć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
kryć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
kryć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kryć: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
kryć się: _: perf: subj{np(str)} + {prepnp(pod,inst)}
kryć się: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
kryć się: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
kryć się: _: perf: subj{np(str)} + {prepnp(w,loc)}
kryć się: _: perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
krytykować: _: imperf: subj{np(str)} + obj{cp(int)}
krytykować: _: imperf: subj{np(str)} + obj{cp(że)}
krytykować: _: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
krytykować: _: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
krytykować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
krytykować: _: imperf: subj{np(str)} + obj{np(str)} + {or}
krytykować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
krzątać się: _: imperf: subj{np(str)} + {prepnp(koło,gen)}
krzątać się: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
krzątać się: _: imperf: subj{np(str)} + {prepnp(wokół,gen)}
krzątać się: _: imperf: subj{np(str)} + {xp(locat)}
krzyczeć: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
krzyczeć: _: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
krzyczeć: _: imperf: subj{np(str)} + {np(dat)} + {np(str)}
krzyczeć: _: imperf: subj{np(str)} + {np(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)} + obj{or} + {np(dat)}
krzyczeć: _: imperf: subj{np(str)} + obj{or} + {prepnp(do,gen)}
krzyczeć: _: imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
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,że)}
krzyczeć: _: imperf: subj{np(str)} + {prepnp(o,acc)}
krzyczeć: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,ż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}
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(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(o,loc)}
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}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
krzywić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
krzyżować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
krzyżować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
krzyżować się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
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ł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łtować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kształtować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
kształtować się: _: imperf: subj{np(str)} + {np(inst)}
kształtować się: _: imperf: subj{np(str)} + {xp(locat)}
kucharzyć: _: imperf: subj{np(str)}
kuć: _: perf: {np(str)} + {xp(locat)}
kuć: _: perf: subj{np(str)} + {lexnp(str,sg,'żelazo',natr)} + {fixed('póki gorące')}
kuć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat); prepnp(dla,gen)} + {np(inst)} + {prepnp(z,gen)}
kuć: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'blacha',natr)}
kuć: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pamięć',natr)}
kuć: _: perf: subj{np(str)} + {prepnp(w,acc)}
kuleć: _: imperf: subj{np(str)} + {comprepnp(z powodu)}
kuleć: _: imperf: subj{np(str)} + {prepnp(na,acc)}
kuleć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
kultywować: _: imperf: subj{np(str)} + obj{np(str)}
kumulować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kumulować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kumulować się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
kupić: _: perf: subj{np(str)} + {np(dat)} + {np(part)}
kupić: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(od,gen)}
kupić: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(u,gen)}
kupić: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(za,acc)}
kupić: _: perf: subj{np(str)} + obj{np(part)} + {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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
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)}
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)}
kwaterować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kwaterować się: _: imperf: subj{np(str)} + {xp(locat)}
kwestionować: _: imperf: subj{np(str)} + {cp(jakoby)}
kwestionować: _: imperf: subj{np(str)} + obj{cp(int)}
kwestionować: _: imperf: subj{np(str)} + obj{cp(że)}
kwestionować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
kwestować: _: imperf: subj{np(str)} + {comprepnp(w sprawie)}
kwestować: _: imperf: subj{np(str)} + {prepnp(dla,gen); prepnp(na,acc)} + {xp(locat)}
kwestować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
kwestować: _: imperf: subj{np(str)} + {prepnp(za,inst)}
kwestować: _: imperf: subj{np(str)} + {xp(locat)} + {preplexnp(z,inst,_,'puszka',atr)}
kwitnąć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
kwitnąć: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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)}
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)}
lakierować: _: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
lakierować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
lakierować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
lamentować: _: imperf: subj{np(str)} + {comprepnp(z powodu)}
lamentować: _: imperf: subj{np(str)} + {cp(int)}
lamentować: _: imperf: subj{np(str)} + {cp(że)}
lamentować: _: imperf: subj{np(str)} + {or}
lamentować: _: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
latać: _: imperf: subj{np(str)} + {np(dat)}
latać: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
latać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
latać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
latać: _: imperf: subj{np(str)} + {prepnp(za,inst)}
latać: _: imperf: subj{np(str)} + {prepnp(z,inst)}
lawirować: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
lawirować: _: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
lawirować: _: imperf: subj{np(str)} + {prepnp(między,inst)}
lądować: _: imperf: subj{np(str)} + {advp(misc)}
lądować: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
lądować: _: imperf: subj{np(str)} + {xp(locat)}
lecieć: _: imperf: {np(dat)} + {advp(misc)}
lecieć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
lecieć: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
lecieć: _: imperf: subj{np(str)} + {prepnp(do,gen)}
lecieć: _: imperf: subj{np(str)} + {prepnp(na,acc)}
lecieć: _: imperf: subj{np(str)} + {prepnp(na,loc)}
lecieć: _: imperf: subj{np(str)} + {prepnp(za,inst)}
lecieć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
leczyć: _: 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)}
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)}
legalizować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
legalizować się: _: imperf: subj{np(str)}
lekceważyć: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
lenić: _: imperf: subj{np(str)} + obj{np(str)}
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)}
leniuchować: _: imperf: subj{np(str)}
lepić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
lepić: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
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ękać się: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
lękać się: _: imperf: subj{np(str)} + {cp(czy)}
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,że); ncp(str,żeby)}
lękać się: _: imperf: subj{np(str)} + {prepncp(o,acc,czy)}
lękać się: _: imperf: subj{np(str)} + {prepncp(o,acc,że)}
lękać się: _: imperf: subj{np(str)} + {prepnp(o,acc)}
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)}
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)}
liczyć się: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
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)}
lokować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
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)}
lokować się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
lokować się: _: imperf: subj{np(str)} + {xp(locat)}
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,że)}
lubić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ładować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
ł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)}
łagodzić: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ł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)}
ł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)}
łasić się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
łasić się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
ł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)}
łatać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ł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ć: _: 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)}
łą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)}
łechtać: _: imperf: {np(str)} + {xp(locat)}
łechtać: _: imperf: subj{cp(gdy)} + {np(str)}
łechtać: _: imperf: subj{cp(int)} + {np(str)}
łechtać: _: imperf: subj{cp(jak)} + {np(str)}
łechtać: _: imperf: subj{cp(kiedy)} + {np(str)}
łechtać: _: imperf: subj{cp(że)} + {np(str)}
łechtać: _: imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
łechtać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
łechtać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
łechtać: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
łechtać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
łechtać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
łechtać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
łechtać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
łkać: _: imperf: subj{np(str)} + {cp(że)}
łkać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
łkać: _: imperf: subj{np(str)} + {np(inst)}
łkać: _: imperf: subj{np(str)} + {prepnp(o,acc)}
łkać: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {or}
łowić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
łowić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
łowić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
łykać: _: imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
łykać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
łyknąć: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
łyknąć: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
łyknąć: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
machać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
machać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
machać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
machać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
machać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
machać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
machać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
machać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
machać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
machać: _: imperf: subj{np(str)} + 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ąć: _: 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)} + 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)}
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)}
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)}
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)}
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)}
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)}
malować: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
malować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
malować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
malować się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
malować się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
małpować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
małpować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
małpować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
małpować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
manipulować: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
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)}
marnować się: _: imperf: subj{np(str)}
marszczyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
martwić: _: imperf: subj{cp(int)} + {np(str)}
martwić: _: imperf: subj{cp(że)} + {np(str)}
martwić: _: imperf: subj{np(str)} + {np(inst)} + {np(str)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
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ć: _: 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(inst)}
mazać się: _: imperf: subj{np(str)} + {cp(że)}
mazać się: _: imperf: subj{np(str)} + {np(inst)}
mdleć: _: imperf: subj{lexnp(str,sg,'serce',natr)} + {prepnp(w,loc)}
mdleć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
mdleć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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ć: _: 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)}
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)}
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ę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)}
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}
miażdżyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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,_,'możliwość',atr); lexnp(str,_,'podstawa',atr); lexnp(str,_,'powód',atr); lexnp(str,_,'szansa',atr); lexnp(str,sg,'chęć',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,'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,'pech',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,sg,'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,sg,'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)} + {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(na,acc)}
mieć: _: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {nonch}
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)}
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)}
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)}
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}
mierzyć się: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
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)}
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)}
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ć: _: imperf: subj{np(str)} + {np(str)}
mieścić się: _: imperf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: _: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: _: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: _: imperf: subj{ncp(str,int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: _: imperf: subj{ncp(str,żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: _: imperf: subj{ncp(str,że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
mieścić się: _: imperf: subj{np(str)} + {xp(locat)}
mięknąć: _: imperf: subj{np(str)} + {np(dat)}
mięknąć: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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}
migać się: _: imperf: subj{np(str)} + {prepnp(od,gen)}
migać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
migotać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
migotać: _: imperf: subj{np(str)} + {np(inst)}
migotać: _: imperf: subj{np(str)} + {prepnp(od,gen)}
mijać: _: 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)}
mijać się: _: imperf: subj{np(str)} + {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)}
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)}
minąć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
mizdrzyć się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
mizdrzyć się: _: imperf: subj{np(str)} + {prepnp(przed,inst)}
mknąć: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
mknąć: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
mnożyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
mnożyć się: _: imperf: subj{np(str)}
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)}
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)}
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}
moczyć się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
modelować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
modelować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
modelować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
modelować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
modelować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
modlić się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {or}
modlić się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {cp(żeby)}
modlić się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,inst)} + {cp(żeby)}
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)}
modyfikować się: _: imperf: subj{np(str)}
monitorować: _: imperf: subj{np(str)} + {cp(int)}
monitorować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
montować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
montować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
moralizować: _: imperf: subj{np(str)} + {comprepnp(na temat)}
moralizować: _: imperf: subj{np(str)} + {comprepnp(w kwestii)}
moralizować: _: imperf: subj{np(str)} + {comprepnp(w sprawie)}
mordować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mordować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
mordować się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
mościć się: _: imperf: subj{np(str)} + {xp(locat)}
motywować: _: imperf: subj{np(str)} + {cp(że)}
motywować: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
motywować: _: imperf: subj{np(str)} + {np(inst)} + {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,żeby)}
motywować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
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)}
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}
mścić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
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)}
musieć: _: imperf: subj,controller{E} + controllee{infp(_)}
musieć: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
musieć: _: imperf: subj{np(str)} + {xp(adl)}
muzykować: _: imperf: subj{np(str)}
myć: _: imperf: subj{np(str)} + {np(inst)} + {refl}
myć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mylić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mylić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,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)}
myśleć: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
myśleć: _: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{prepadjp(jako,str)}
myśleć: _: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{prepnp(jako,str)}
myśleć: _: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
myśleć: _: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
myśleć: _: imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
myśleć: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
myśleć: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nabawić: _: imperf: subj{np(str)} + {np(gen)} + {np(str)}
nabawić się: _: perf: subj{np(str)} + {np(gen)}
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)}
nabić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
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)}
nabierać się: _: imperf: subj{np(str)} + {cp(że)}
nabierać się: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,ż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)}
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)}
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)}
nabrać się: _: perf: subj{np(str)} + {cp(że)}
nabrać się: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabroić: _: perf: subj{np(str)} + {nonch}
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)}
nabyć się: _: perf: subj{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)}
nachmurzyć: _: perf: subj{np(str)} + obj{np(str)}
nachmurzyć się: _: perf: subj{np(str)}
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)}
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)}
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)}
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)}
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)}
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)}
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ąć 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ą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ągać się: _: imperf: 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)}
naciągnąć się: _: perf: subj{np(str)} + {prepnp(o,acc)}
nacierać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nacierać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
nacierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nacierać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nacierać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nacierać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
nacierać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
nacierać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
nacieszyć: _: perf: subj{np(str)} + {np(inst)} + {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)}
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)}
nacinać się: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nacinać się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
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)}
naciskać: _: perf: subj{np(str)} + {np(gen)} + {xp(adl)}
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}
nadać: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {or}
nadać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nadać się: _: perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby)}
nadarzać: _: imperf: subj{np(str)} + {np(dat)} + {np(str)}
nadarzać się: _: imperf: subj{np(str)} + {np(dat)}
nadarzyć: _: perf: subj{np(str)} + {np(dat)} + {np(str)}
nadarzyć się: _: perf: subj{np(str)} + {np(dat)}
nadawać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {or}
nadawać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nadawać: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)}
nadawać się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby)}
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ć: _: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nadążyć: _: imperf: subj{np(str)} + {cp(żeby)}
nadążyć: _: imperf: subj{np(str)} + {prepnp(za,inst)}
nadążyć: _: imperf: subj{np(str)} + {prepnp(z,inst)}
nadbiec: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadbiegać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
nadchodzić: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
nadcią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)}
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)}
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)}
nadkładać: _: imperf: subj{np(str)} + {np(str)} + {xp(adl)}
nadkładać: _: imperf: subj{np(str)} + {np(str)} + {xp(perl)}
nadkładać: _: imperf: subj{np(str)} + {xp(adl)} + {lexnp(gen,sg,'droga',natr)}
nadkładać: _: imperf: subj{np(str)} + {xp(perl)} + {lexnp(gen,sg,'droga',natr)}
nadł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)}
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)}
nadskakiwać: _: imperf: subj{np(str)} + {np(dat)}
nadsyłać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
nadsyłać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
nadużyć: _: perf: subj{np(str)} + obj{np(gen)}
nadużywać: _: imperf: subj{np(str)} + obj{np(gen)}
nadziwić się: _: perf: subj{np(str)} + {np(dat); cp(int); cp(że); ncp(dat,int); ncp(dat,że)}
nadzorować: _: imperf: subj{np(str)} + obj{np(str)}
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}
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)}
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}
nagiąć się: _: perf: subj{np(str)} + {np(gen)} + {np(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}
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ć się: _: perf: subj{np(str)} + {np(gen)}
nagrać się: _: perf: subj{np(str)} + {prepnp(na,loc)}
nagrać się: _: perf: subj{np(str)} + {xp(locat)}
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)}
najść się: _: perf: {np(gen)} + {xp(abl)} + {xp(adl)}
nakarmić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nakarmić się: _: perf: subj{np(str)} + {np(inst)}
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)}
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ł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ć: _: 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łuć się: _: perf: 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)}
nakłuwać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
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}
nakręcić się: _: perf: subj{np(str)} + {np(inst)}
nakryć: _: perf: subj{lexnp(str,sg,'diabeł',natr)} + {np(str)} + {lexnp(inst,sg,'ogon',natr)}
nakryć: _: perf: subj{np(str)} + {np(inst)} + {refl}
nakryć: _: perf: subj{np(str)} + obj{np(str)} + {cp(gdy)} + {xp(locat)}
nakryć: _: perf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {xp(locat)}
nakryć: _: perf: subj{np(str)} + obj{np(str)} + {cp(kiedy)} + {xp(locat)}
nakryć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakryć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nakryć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
nakrywać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
nakrywać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(gdy)} + {xp(locat)}
nakrywać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(jak)} + {xp(locat)}
nakrywać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(kiedy)} + {xp(locat)}
nakrywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakrywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nakrywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że)}
nalać: _: 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)}
nalać się: _: perf: subj{np(part)} + {np(dat)} + {xp(adl)} + {xp(perl)}
nalegać: _: imperf: subj{np(str)} + {or}
nalegać: _: imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
nalegać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nalegać: _: imperf: subj{np(str)} + {prepnp(o,acc)}
nalewać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nalewać się: _: imperf: subj{np(part)} + {np(dat)} + {xp(adl)} + {xp(perl)}
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żeć się: _: imperf: subj{cp(żeby)} + {np(dat)}
należeć się: _: imperf: subj{np(str)} + {np(dat)}
należeć się: _: perf: subj{np(str)} + {xp(locat)}
naliczać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
naliczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
naliczyć się: _: perf: subj{np(str)} + {np(gen)}
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}
namawiać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
namówić się: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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ść: _: 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)}
nanieść się: _: perf: {np(part)} + {xp(abl)} + {xp(adl)}
nanieść się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
nanosić: _: _: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
nanosić się: _: perf: subj{np(str)} + {np(gen)}
nanosić się: _: _: {np(part)} + {xp(abl)} + {xp(adl)}
nanosić się: _: _: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
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}
napaść się: _: perf: subj{np(str)} + {np(inst)}
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ć: _: 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)}
napawać się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
napchać się: _: perf: {np(part)} + {xp(adl)}
napchać się: _: perf: subj{np(str)} + {xp(adl)}
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ąć: _: perf: subj{np(str)} + obj{np(str)}
napiąć się: _: perf: subj{np(str)} + {np(dat)}
napić się: _: perf: subj{np(str)} + {np(gen)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
napić się: _: perf: subj{np(str)} + {np(inst)}
napierać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
napierać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
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)}
napinać: _: imperf: subj{np(str)} + obj{np(str)}
napinać się: _: imperf: subj{np(str)} + {np(dat)}
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)} + {prepnp(na,loc)}
napisać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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)}
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ć: _: 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)}
napływać się: _: perf: subj{np(str)}
napoić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napoić się: _: perf: subj{np(str)} + {np(inst)}
napotkać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napotkać: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
napotkać: _: perf: subj{np(str)} + {prepnp(na,acc)}
napotykać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napotykać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
napotykać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
naprawiać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
naprawiać się: _: imperf: subj{np(str)}
naprawić: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
naprawić się: _: perf: subj{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)}
naprzeć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
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)}
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)}
napychać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
napychać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
napychać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
naradzać się: _: imperf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
naradzać się: _: imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(z,inst)}
naradzać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
naradzać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
naradzać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
naradzać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
naradzać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(nad,inst,int)}
narastać: _: imperf: {np(gen)} + {xp(locat)}
narastać: _: imperf: subj{np(str)} + {np(dat)}
narastać: _: imperf: subj{np(str)} + {prepnp(w,loc)}
narastać: _: imperf: subj{np(str)} + {xp(dur)}
narastać: _: imperf: subj{np(str)} + {xp(locat)}
narazić: _: 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,acc)}
narazić: _: perf: subj{np(str)} + {prepnp(dla,gen)} + {refl}
narazić się: _: perf: 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}
narażać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
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)}
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)}
narzucać: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
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ć się: _: perf: subj{np(str)} + {np(gen)}
narzucać się: _: perf: subj{np(str)} + {np(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)}
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)}
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ączać się: _: imperf: 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)}
nasączyć się: _: perf: subj{np(str)} + {np(inst)}
nasilać: _: imperf: subj{np(str)} + obj{np(str)}
nasilać się: _: imperf: subj{np(str)}
nasilić: _: perf: subj{np(str)} + obj{np(str)}
nasilić się: _: perf: subj{np(str)}
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)}
nastać: _: perf: subj{np(str)} + {xp(locat)}
nastać się: _: perf: subj{np(str)} + {xp(locat)}
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ć: _: 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)}
nastawiać: _: perf: subj{np(str)} + {np(gen)} + {xp(locat)}
nastawiać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
nastawiać się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
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ć: _: 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)}
nastrajać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
nastrajać się: _: imperf: 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)}
nastroić się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
nastroić się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastroszyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
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)}
nasuwać: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
nasuwać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: _: perf: subj{cp(że)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
naścinać: _: perf: subj{np(str)} + obj{np(part)}
naśladować: _: imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
naśladować: _: imperf: subj{np(str)} + obj{np(str)}
naśmiewać się: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
naśmiewać się: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
naśmiewać się: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
naśmiewać się: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
natchnąć: _: perf: {np(str)} + {cp(żeby)}
natchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
natchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
natknąć się: _: perf: subj{np(str)} + {prepncp(na,acc,int)}
natknąć się: _: perf: subj{np(str)} + {prepncp(na,acc,że)}
natknąć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
natrafiać: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrafić: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrzeć: _: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'ucho',natr)}
natrzeć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
natrzeć: _: perf: subj{np(str)} + {np(inst)} + {refl}
natrzeć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
natrzeć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
natrzeć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
natrzeć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
natrzeć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
natrzeć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
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ć: _: 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}
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}
nawadniać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
nawadniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nawadniać się: _: imperf: subj{np(str)} + {np(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)}
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)}
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)}
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)}
nawiązać: _: perf: subj{np(str)} + {np(gen)}
nawiązać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
nawiązać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
nawiązać: _: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
nawiązać się: _: perf: subj{np(str)} + {prepnp(między,inst)}
nawiedzać: _: imperf: subj{np(str)} + obj{np(str)}
nawiedzić: _: perf: subj{np(str)} + obj{np(str)}
nawilgacać: _: imperf: subj{np(str)} + obj{np(str)}
nawilgacać się: _: imperf: subj{np(str)}
nawodnić: _: perf: subj{np(str)} + {np(inst)} + {refl}
nawodnić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nawodnić się: _: perf: subj{np(str)} + {np(inst)}
nawozić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nawozić: _: perf: subj{np(str)} + {np(gen)}
nawozić się: _: perf: subj{np(str)} + {np(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)}
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)}
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)}
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)}
nazbierać: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(adl)}
nazbierać się: _: perf: {np(dat)} + {xp(locat)}
nazbierać się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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,loc)}
nazwać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nazwać: _: perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
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)}
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)}
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)}
nękać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,że)}
niecierpliwić: _: imperf: subj{cp(że)} + {np(str)}
niecierpliwić: _: imperf: subj{np(str); ncp(str,że)} + {np(str)}
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)}
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}
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)}
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)}
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}
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)}
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ć: _: imperf: subj{np(str)} + {np(inst)} + {refl}
niszczyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
niszczyć się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
nocować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nocować: _: imperf: subj{np(str)} + {xp(locat)} + {preplexnp(na,acc,sg,'walet',natr)}
nominować: _: _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nominować: _: _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nominować: _: _: subj{np(str)} + {prepnp(do,gen)} + {refl}
nominować: _: _: subj{np(str)} + {prepnp(na,acc)} + {refl}
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)}
nosić się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
nosić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
notować: _: imperf: subj{np(str)} + {cp(żeby2)}
notować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
notować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
notować: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
notować: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
notować: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {or}
notować: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
notować: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
notować: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {or}
nowelizować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)} + {cp(że)}
nudzić: _: imperf: subj{np(str); ncp(str,że)} + {np(str)}
nudzić: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); 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}
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)}
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)}
obałamucić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obawiać się: _: imperf: subj{np(str)} + {cp(int)}
obawiać się: _: imperf: subj{np(str)} + {cp(żeby)}
obawiać się: _: imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); infp(_)}
obawiać się: _: imperf: subj{np(str)} + {prepnp(o,acc); cp(że); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
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)}
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)}
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ąć 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)}
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)}
obcierać się: _: imperf: subj{np(str)} + {np(dat)}
obcierać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
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)}
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)}
obcować: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
obejmować się: _: imperf: subj{np(str)} + {prepnp(z,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}
obejrzeć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
obejrzeć się: _: perf: subj{np(str)} + {prepnp(za,inst)}
obejść: _: perf: subj{cp(że)} + {np(str)}
obejść: _: perf: subj{np(str)} + {np(str)} + {xp(abl)}
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)}
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)}
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)}
obeschnąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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)}
obetrzeć się: _: perf: subj{np(str)} + {np(dat)}
obetrzeć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
obfitować: _: imperf: subj{np(str)} + {np(inst)}
obfitować: _: imperf: subj{np(str)} + {prepnp(w,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)}
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)}
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)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
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)}
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)}
objąć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
objechać: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
objechać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
objechać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
objeżdżać: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
objeżdżać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
objeżdżać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
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)}
oblać się: _: perf: subj{np(str)} + {np(inst)}
oblegać: _: imperf: subj{np(str)} + obj{np(str)}
oblepiać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
oblepiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblepiać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
oblepiać się: _: imperf: 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)}
oblepić się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
oblepić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
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)}
oblewać się: _: imperf: subj{np(str)} + {np(inst)}
obliczać: _: imperf: subj{np(str)} + {cp(int)}
obliczać: _: imperf: subj{np(str)} + {cp(że)}
obliczać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obliczać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,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ć: _: imperf: 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łowić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obłowić się: _: perf: subj{np(str)} + {np(inst)}
obłowić się: _: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
obmyślać: _: imperf: subj{np(str)} + {cp(int)}
obmyślać: _: imperf: subj{np(str)} + obj{np(str)}
obmyślić: _: perf: subj{np(str)} + {cp(int)}
obmyślić: _: perf: subj{np(str)} + obj{np(str)}
obnażać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
obnażać się: _: imperf: subj{np(str)} + {prepnp(przed,inst)}
obnażyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
obnażyć się: _: perf: subj{np(str)} + {prepnp(przed,inst)}
obowiązywać: _: imperf: subj{np(str)} + {np(str)}
obowiązywać: _: imperf: subj{np(str)} + {xp(dur)}
obrabiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrabiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obrabować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obrabować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obracać: _: 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)}
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)}
obrać: _: perf: subj{np(str)} + {np(inst)} + {refl}
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)}
obrać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
obradować: _: imperf: subj{np(str)} + {prepnp(nad,inst); comprepnp(w sprawie); prepncp(nad,inst,int)}
obradować: _: imperf: subj{np(str)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int)}
obrastać: _: imperf: subj{np(str)} + {np(inst)}
obrastać: _: imperf: subj{np(str)} + obj{np(str)}
obrastać: _: imperf: subj{np(str)} + {prepnp(w,acc)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obrażać się: _: imperf: subj{np(str)} + {or}
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,że)}
obrażać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepncp(o,acc,że)}
obrażać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepncp(za,acc,że)}
obrażać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc)}
obrażać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
obrączkować: _: imperf: subj{np(str)} + obj{np(str)}
obrobić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obrobić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
obrobić się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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ć: _: 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)}
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)}
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ć: _: 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)}
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)}
obrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obrzucić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obsadzać: _: perf: subj{np(str)} + {np(inst)} + {refl}
obsadzać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsadzać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
obsadzać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obsadzać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obsadzać: _: perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
obsadzać: _: perf: 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)}
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}
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ć: _: 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)}
obstawiać się: _: imperf: subj{np(str)} + {np(inst)}
obstawić: _: perf: subj{np(str)} + {cp(int)}
obstawić: _: perf: subj{np(str)} + {cp(że)}
obstawić: _: perf: subj{np(str)} + {np(inst)} + {refl}
obstawić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obstawić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
obstawić: _: perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
obsunąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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)}
obsuwać: _: imperf: 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)}
obsychać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
obsypać: _: perf: subj{np(str)} + {np(inst)} + {refl}
obsypać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsypać się: _: perf: subj{np(str)} + {xp(abl)}
obsypać się: _: perf: 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)}
obsypywać się: _: imperf: subj{np(str)} + {xp(abl)}
obsypywać się: _: imperf: subj{np(str)} + {xp(adl)}
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)}
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ć: _: 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)}
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)}
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(inst)} + {np(str)}
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,że)}
oburzać się: _: imperf: subj{np(str)} + {prepnp(o,acc); 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(inst)} + {np(str)}
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,że)}
oburzyć się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
obuwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
obuwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obuwać: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obwiesić: _: 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)}
obwiesić się: _: perf: 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)}
obwieszać się: _: imperf: subj{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)}
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)}
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}
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}
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ć: _: imperf: subj{np(str)} + {np(inst)} + {refl}
ochładzać: _: 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łodzić: _: perf: subj{np(str)} + {np(inst)} + {refl}
ochłodzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ochłodzić się: _: perf: subj{np(str)} + {prepnp(o,acc)}
ochłodzić się: _: perf: {xp(locat)}
ochłonąć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
ochraniać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochraniać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {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}
ochronić: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochronić: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {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}
ochrzcić: _: perf: subj{np(str)} + {np(inst)} + {refl}
ochrzcić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ochrzcić się: _: perf: subj{np(str)}
ociągać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
ocierać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
ocierać się: _: imperf: subj{np(str)} + {xp(locat)}
ociosać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ociosać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ociosać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ociosać: _: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
ociosywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ociosywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ociosywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ociosywać: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
ocknąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ocknąć się: _: perf: subj{np(str)} + {prepnp(z,gen)}
ocucić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
ocucić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
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)}
oczarować się: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
oczekiwać: _: imperf: subj{np(str)} + {cp(aż)}
oczekiwać: _: imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(od,gen)}
oczekiwać: _: imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(po,loc)}
oczekiwać: _: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(od,gen)}
oczekiwać: _: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(po,loc)}
oczekiwać: _: imperf: subj{np(str)} + obj{np(gen); ncp(gen,że); ncp(gen,żeby)} + {prepnp(od,gen)}
oczekiwać: _: imperf: subj{np(str)} + obj{np(gen); 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}
odbezpieczać: _: imperf: subj{np(str)} + obj{np(str)}
odbezpieczać się: _: imperf: subj{np(str)} + {np(dat)}
odbezpieczyć: _: perf: subj{np(str)} + obj{np(str)}
odbezpieczyć się: _: perf: subj{np(str)} + {np(dat)}
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)} + {prepnp(od,gen)}
odbierać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odbijać: _: imperf: {np(dat)}
odbijać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbijać: _: imperf: subj{np(str)} + {np(str)} + {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)}
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(od,gen)}
odbijać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odbijać: _: imperf: subj{np(str)} + {xp(abl)}
odbijać: _: imperf: subj{np(str)} + {xp(adl)}
odbijać się: _: imperf: {np(dat)} + {np(inst)}
odbijać się: _: imperf: {np(dat)} + {prepnp(po,loc)}
odbijać się: _: imperf: subj{np(str)} + controller{prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)} + controllee{xp(mod)}
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)} + {prepnp(na,loc); prepnp(w,loc)}
odbijać się: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(inst,sg,'echo',atr)}
odbijać się: _: imperf: subj{np(str)} + {xp(locat)} + {lexnp(inst,sg,'echo',atr)}
odbudować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbudować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odbudować się: _: perf: subj{np(str)} + {prepnp(z,gen)}
odbyć: _: perf: subj{np(str)} + obj{np(str)}
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)}
odbywać: _: imperf: 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)}
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)} + {comprepnp(na rzecz)}
odchodzić: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(od,gen,pl,'zmysł',natr)}
odchodzić: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {preplexnp(od,gen,sg,'rozum',natr)}
odchodzić: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odchodzić: _: imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
odchować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odchować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odchować się: _: perf: 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)}
odchowywać się: _: imperf: subj{np(str)}
odciąć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odciąć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odciąć się: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odciąć się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odciąć się: _: imperf: subj{np(str)} + {np(dat)} + {or}
odciąć 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)}
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)}
odczekać: _: perf: subj{np(str)} + {np(str)} + {cp(aż)}
odczuć: _: perf: subj{np(str)} + {cp(żeby2)}
odczuć: _: perf: subj{np(str)} + {np(inst)} + {cp(int)}
odczuć: _: perf: subj{np(str)} + {np(inst)} + {cp(że)}
odczuć: _: perf: subj{np(str)} + {np(str)} + {xp(locat)}
odczuć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
odczuwać: _: imperf: subj{np(str)} + {cp(int)}
odczuwać: _: imperf: subj{np(str)} + {cp(jak)}
odczuwać: _: imperf: subj{np(str)} + {cp(jakoby)}
odczuwać: _: imperf: subj{np(str)} + {cp(że)}
odczuwać: _: imperf: subj{np(str)} + {cp(żeby2)}
odczuwać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczuwać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2)}
odczytać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczytać: _: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odczytać: _: perf: subj{np(str)} + {or}
odczytywać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczytywać: _: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odczytywać: _: imperf: subj{np(str)} + {or}
oddać: _: 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)}
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)}
oddalać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
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)}
oddalić: _: perf: 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)}
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)}
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)}
oddychać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst); prepnp(przez,acc)}
oddychać: _: imperf: subj{np(str)} + {np(inst); prepnp(przez,acc)}
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)} + {prepnp(od,gen)}
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)}
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)}
odegrać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
odegrać się: _: perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,że)}
odegrać się: _: perf: subj{np(str)} + {prepnp(w,acc)}
odegrać się: _: perf: subj{np(str)} + {xp(locat)}
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)} + {comprepnp(na rzecz)}
odejść: _: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odepchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odepchnąć się: _: perf: subj{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ć: _: 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)}
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)}
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)}
odetchnąć: _: perf: subj{np(str)} + {np(inst)}
odetchnąć: _: perf: subj{np(str)} + {prepnp(po,loc)}
odetchnąć: _: perf: subj{np(str)} + {prepnp(przed,inst)}
odezwać się: _: perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)} + {or}
odezwać się: _: perf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
odezwać się: _: perf: subj{np(str)} + {cp(że)}
odezwać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odezwać się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
odezwać się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
odezwać się: _: perf: subj{np(str)} + {prepnp(o,loc)} + {or}
odezwać się: _: perf: subj{np(str)} + {prepnp(przeciw,dat)}
odezwać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
odformalizować: _: perf: subj{np(str)} + obj{np(str)}
odgadnąć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odgadnąć: _: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odgadnąć: _: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
odgadywać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odgadywać: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odgadywać: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
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)}
odgrażać się: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odgrażać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odgrażać się: _: imperf: subj{np(str)} + {np(dat)} + {or}
odgrywać: _: 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)}
odgrywać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
odgrywać się: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,że)}
odgrywać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
odgrywać się: _: imperf: subj{np(str)} + {xp(locat)}
odgryzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odgryzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
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)}
odgryźć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odgryźć: _: perf: subj{np(str)} + obj{np(str)} + {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)}
odgrzać: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
odgrzać się: _: perf: subj{np(str)} + {xp(locat)}
odgrzewać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(locat)}
odgrzewać się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
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ładać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
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ę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ę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)}
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)}
odkryć: _: perf: subj{np(str)} + {ncp(str,int)}
odkryć: _: perf: subj{np(str)} + {ncp(str,że)}
odkryć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odkryć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
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)}
odkryć się: _: perf: subj{np(str)} + {prepnp(przed,inst)}
odkrywać: _: imperf: subj{np(str)} + {ncp(str,int)}
odkrywać: _: imperf: subj{np(str)} + {ncp(str,że)}
odkrywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odkrywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
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)}
odkrywać się: _: imperf: subj{np(str)} + {prepnp(przed,inst)}
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ł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ł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)}
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)}
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)}
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)}
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)}
odkupić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odkurzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkurzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odkurzyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odkurzyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odkuwać: _: 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)}
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)}
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)}
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)}
odliczać się: _: imperf: 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)}
odliczyć się: _: perf: subj{np(str)} + {xp(locat)}
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ł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ł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ł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łączyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odłączyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odłączyć się: _: perf: subj{np(str)} + {prepnp(od,gen)}
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łożyć się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
odmieniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
odmieniać się: _: imperf: subj{np(str)} + {prepnp(przez,acc)}
odmówić: _: perf: subj{np(str)} + obj{np(gen); ncp(gen,że)} + {np(dat)}
odmówić: _: perf: subj{np(str)} + obj{np(str)}
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)}
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)}
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)}
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)}
odnawiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odnawiać się: _: imperf: subj{np(str)} + {np(dat)}
odnawiać się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
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)}
odnieść się: _: perf: 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)}
odnosić się: _: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
odnowić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odnowić się: _: perf: subj{np(str)} + {np(dat)}
odnowić się: _: perf: subj{np(str)} + {prepnp(u,gen)}
odpalać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpalać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpalać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpalać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odpalać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odpalać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odpalać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpalać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odpalać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odpalać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odpalić: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpalić: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpalić: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpalić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odpalić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odpalić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odpalić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpalić: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odpalić: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odpalić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odparować: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
odparować: _: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odparować: _: perf: subj{np(str)} + {np(dat)} + {or}
odparować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odparować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odparować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odparować: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odparować: _: perf: subj{np(str)} + {xp(abl)}
odparować: _: perf: subj{np(str)} + {xp(adl)}
odparowywać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odparowywać: _: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odparowywać: _: imperf: subj{np(str)} + {np(dat)} + {or}
odparowywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odparowywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odparowywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odparowywać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odparowywać: _: imperf: subj{np(str)} + {xp(abl)}
odparowywać: _: imperf: subj{np(str)} + {xp(adl)}
odpędzać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odpędzać: _: perf: 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ąć: _: 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}
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)}
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)}
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}
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ł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ł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ł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łynąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odpłynąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpłynąć: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odpływać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odpływać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpływać: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odpocząć: _: perf: subj{np(str)} + {prepnp(od,gen)}
odpocząć: _: perf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
odpoczywać: _: imperf: subj{np(str)} + {preplexnp(w,loc,sg,'pokój',atr)}
odpoczywać: _: imperf: subj{np(str)} + {prepnp(od,gen)}
odpoczywać: _: imperf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
odpowiadać: _: imperf: subj,controllee{infp(_)} + controller{np(dat)}
odpowiadać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(na,acc)}
odpowiadać: _: imperf: subj{cp(że)} + {np(dat)}
odpowiadać: _: imperf: subj{np(str)} + {ncp(dat,żeby)}
odpowiadać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
odpowiadać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odpowiadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpowiadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpowiadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpowiadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpowiadać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odpowiadać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odpowiadać: _: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
odpowiadać: _: imperf: subj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
odpowiadać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
odpowiedzieć: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(na,acc)}
odpowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odpowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpowiedzieć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odpowiedzieć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odpowiedzieć: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpowiedzieć: _: perf: subj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
odpowiedzieć: _: perf: subj{np(str)} + {prepnp(z,gen)}
odprawiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odprawiać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
odprawiać się: _: imperf: subj{np(str)} + {xp(locat)}
odprawić: _: perf: 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)}
odprowadzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odprowadzić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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ć: _: imperf: subj{np(str); ncp(str,że)} + {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)}
odpychać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odpytać: _: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
odpytać: _: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
odpytać: _: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
odpytać: _: perf: subj{np(str)} + obj{np(str)} + {or}
odpytać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
odpytać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int)}
odpytywać: _: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
odpytywać: _: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
odpytywać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
odpytywać: _: imperf: subj{np(str)} + obj{np(str)} + {or}
odpytywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
odpytywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int)}
odrabiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odradzać: _: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odradzać: _: imperf: subj{np(str)} + {np(dat)} + {ncp(str,żeby)}
odradzać: _: imperf: subj{np(str)} + {np(dat)} + {or}
odradzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odradzać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
odrobić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
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óżniać się: _: imperf: 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)}
odróżnić się: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(od,gen)}
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)}
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)}
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}
odrzec się: _: perf: subj{np(str)} + {np(gen)}
odrzec się: _: perf: subj{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)} + {xp(adl)}
odrzucić: _: perf: {np(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)} + {prepnp(do,gen)}
odrzucić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odrzucić: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odsądzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsądzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsiadywać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odsiedzieć: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odsłaniać: _: 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ł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ł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ł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)}
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)}
odstawać się: _: imperf: subj{np(str)}
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)}
odstawić się: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
odstawić się: _: perf: subj{np(str)} + {prepnp(w,acc)}
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)}
odstraszać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
odstraszać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
odstraszyć: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
odstraszyć: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
odsuwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsuwać: _: imperf: 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)}
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)}
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)}
odtańczyć: _: perf: subj{np(str)} + obj{np(str)}
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)}
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)}
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)}
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)}
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)}
odwiedzać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odwiedzić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
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)}
odwlec się: _: perf: subj{np(str)} + {prepnp(o,acc)}
odwlec się: _: perf: 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)}
odwlekać się: _: imperf: subj{np(str)} + {prepnp(o,acc)}
odwlekać się: _: imperf: subj{np(str)} + {xp(dur)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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(od,gen)}
odwołać się: _: perf: subj{np(str)} + {prepnp(od,gen)} + {prepncp(od,gen,że)}
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)}
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)}
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)}
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)}
odwzajemniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odwzajemniać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,że)}
odwzajemnić: _: perf: 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,że)}
odziedziczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
odznaczać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
odznaczać się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
odznaczać się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
odznaczyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
odznaczyć się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
odznaczyć się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
odzwierciedlać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
odzwierciedlać się: _: imperf: 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)}
odzwierciedlić się: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,ż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żyć: _: perf: subj{np(str)} + {np(inst)}
odżywać: _: 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żywiać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
odżywiać się: _: imperf: subj{np(str)} + {np(inst)}
oferować: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oferować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
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)}
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)}
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)}
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)}
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)}
ogarniać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
ogarniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ogarniać się: _: imperf: subj{np(str)}
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ą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)}
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łaszać się: _: imperf: subj{np(str)} + {or}
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łupiać: _: imperf: subj{np(str)} + {cp(że)} + {refl}
ogłupiać: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
ogłupiać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
ogłupiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ogłupić: _: perf: subj{np(str)} + {cp(że)} + {refl}
ogłupić: _: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
ogłupić: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
ogłupić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
ogłuszać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
ogłuszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ogłuszyć: _: perf: subj{np(str)} + {np(inst)} + {refl}
ogłuszyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ogolić: _: perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
ogolić: _: perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
ogolić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
ogolić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ogolić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
ogolić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ograniczać: _: 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)}
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)}
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)}
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)}
okazać: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
okazać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
okazywać: _: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
okazywać: _: imperf: 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)}
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ć: _: 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ładać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
okocić się: _: perf: subj{np(str)}
okradać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okradać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
okraść: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okraść: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
okrążać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
okrążać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
okrążać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
okrążyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
okrążyć: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
okrążyć: _: perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
określać: _: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
określać: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
określać: _: imperf: subj{np(str)} + {cp(int)}
określać: _: imperf: subj{np(str)} + {cp(że)}
określać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
określać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
określać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
określać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
określać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
określić: _: 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)}
określić się: _: perf: subj{np(str)} + {cp(int)}
określić się: _: perf: subj{np(str)} + {cp(że)}
okrwawić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
okrwawić się: _: perf: subj{np(str)}
okrzepnąć: _: perf: subj{np(str)} + {prepnp(w,loc)}
okupować: _: imperf: subj{np(str)} + obj{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)}
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)}
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)}
omówić: _: perf: subj{np(str)} + {cp(int)}
omówić: _: perf: subj{np(str)} + {cp(że)}
omówić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
omylić: _: perf: subj{np(str)} + obj{np(str)}
omylić się: _: perf: subj{np(str)} + {prepnp(co do,gen)}
omylić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
oniemieć: _: perf: subj{np(str)} + {prepnp(z,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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opalać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
opalać się: _: imperf: subj{np(str)}
opanować: _: perf: subj{np(str)} + obj{np(str)}
opanować się: _: perf: subj{np(str)}
opanowywać: _: imperf: subj{np(str)} + obj{np(str)}
opanowywać się: _: imperf: subj{np(str)}
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)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opatrzyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
opatrzyć się: _: perf: subj{np(str)} + {np(dat)}
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ć: _: 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ę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ę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ę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)}
opić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opić się: _: perf: subj{np(str)} + {np(gen)}
opić się: _: perf: subj{np(str)} + {np(inst)}
opiekować się: _: imperf: subj{np(str)} + {np(inst)}
opierać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
opierać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,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)}
opiewać: _: imperf: subj{np(str)} + obj{np(str)}
opiewać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
opijać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opijać się: _: imperf: subj{np(str)} + {np(gen)}
opijać się: _: imperf: subj{np(str)} + {np(inst)}
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{cp(int)} + {np(dat)}
opisać: _: perf: subj{np(str)} + obj{ncp(str,int)} + {np(dat)}
opisać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
opisać: _: perf: subj{np(str)} + {or}
opisywać: _: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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łacić: _: perf: 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łakiwać: _: imperf: subj{np(str)} + obj{np(str)}
opłukać: _: perf: subj{np(str)} + {np(inst)} + {refl}
opłukać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opłukać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opłukać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
opłukać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
opłukać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
opłukać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opłukać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
opłukać: _: perf: subj{np(str)} + {prepnp(pod,inst)} + {refl}
opłukać: _: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
opłukać: _: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
oponować: _: imperf: subj{np(str)} + {cp(jakoby)}
oponować: _: imperf: subj{np(str)} + {cp(że)}
oponować: _: imperf: subj{np(str)} + {cp(żeby)}
oponować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
oponować: _: imperf: subj{np(str)} + {or}
oponować: _: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,jakoby); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
oporządzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
oporządzać: _: imperf: subj{np(str)} + {refl}
oporządzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
oporządzić: _: perf: subj{np(str)} + {refl}
opowiadać: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
opowiadać: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
opowiadać: _: imperf: subj{np(str)} + {np(dat)} + {or}
opowiadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
opowiadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {nonch}
opowiadać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
opowiadać: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
opowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
opowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {cp(int)}
opowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {or}
opowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
opowiedzieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {nonch}
opowiedzieć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opowiedzieć: _: perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
opóźniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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óźnić: _: perf: 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)}
opracować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opracować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opróżniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
opróżniać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
opróżnić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
opróżnić się: _: perf: subj{np(str)} + {prepnp(z,gen)}
oprzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
oprzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
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)}
opublikować: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
opustoszeć: _: perf: subj{np(str)} + {prepnp(z,gen)}
orać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
orać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
orać: _: imperf: subj{np(str)} + {prepnp(w,acc)}
orzec: _: perf: subj{np(str)} + {comprepnp(w sprawie)}
orzec: _: perf: subj{np(str)} + {cp(int)}
orzec: _: perf: subj{np(str)} + {cp(że)}
orzec: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
orzec: _: perf: subj{np(str)} + {or}
orzec: _: perf: subj{np(str)} + {prepnp(co do,gen)}
orzec: _: perf: subj{np(str)} + {prepnp(na,acc)}
orzec: _: perf: subj{np(str)} + {prepnp(o,loc)}
orzekać: _: imperf: subj{np(str)} + {comprepnp(w sprawie)}
orzekać: _: imperf: subj{np(str)} + {cp(int)}
orzekać: _: imperf: subj{np(str)} + {cp(że)}
orzekać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
orzekać: _: imperf: subj{np(str)} + {or}
orzekać: _: imperf: subj{np(str)} + {prepnp(co do,gen)}
orzekać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
orzekać: _: imperf: subj{np(str)} + {prepnp(o,loc)}
osądzać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
osądzać: _: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
osądzać: _: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
osądzać: _: imperf: subj{np(str)} + {cp(int)}
osądzać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
osądzać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
osądzać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
osądzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
osądzać: _: imperf: subj{np(str)} + {or}
osądzić: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
osądzić: _: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
osądzić: _: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
osądzić: _: perf: subj{np(str)} + {cp(int)}
osądzić: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
osądzić: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
osądzić: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
osądzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
osądzić: _: perf: subj{np(str)} + {or}
oscylować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
oscylować: _: imperf: subj{np(str)} + {prepnp(między,inst)}
oscylować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
oscylować: _: imperf: subj{np(str)} + {prepnp(w,loc)}
oscylować: _: imperf: subj{np(str)} + {prepnp(wokół,gen)}
oscylować: _: imperf: subj{np(str)} + {xp(adl)}
osiadać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
osiedlać się: _: imperf: subj{np(str)} + {xp(locat)}
osiedlić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
osiedlić się: _: perf: subj{np(str)} + {xp(locat)}
osierocić: _: perf: subj{np(str)} + obj{np(str)}
osiodłać: _: perf: subj{np(str)} + obj{np(str)}
osiwieć: _: perf: subj{np(str)} + {np(dat)}
osiwieć: _: perf: subj{np(str)} + {xp(locat)}
oskarżać: _: imperf: subj{np(str)} + {cp(że)} + {refl}
oskarżać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oskarżać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(wobec,gen)}
oskarżać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or}
oskarżać: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or} + {refl}
oskarżyć: _: perf: subj{np(str)} + {cp(że)} + {refl}
oskarżyć: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
oskarżyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(wobec,gen)}
oskarżyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or}
oskarżyć: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or} + {refl}
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łaniać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
osłaniać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
osłaniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
osłaniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
osłonić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
osłonić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
osłonić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
osłonić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
osmalić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
osmalić się: _: perf: subj{np(str)}
osowieć: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
ostać: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ostać: _: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
ostać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ostać się: _: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
ostemplować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ostrzec: _: perf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
ostrzec: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepnp(przed,inst); prepncp(o,loc,że); prepncp(przed,inst,że)}
ostrzec: _: perf: subj{np(str)} + {or}
ostrzegać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
ostrzegać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepnp(przed,inst); prepncp(o,loc,że); prepncp(przed,inst,że)}
ostrzegać: _: imperf: subj{np(str)} + {or}
ostrzelać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ostrzelać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ostrzelać się: _: perf: subj{np(str)}
ostrzeliwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ostrzeliwać: _: imperf: 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)}
ostrzyc: _: perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
ostrzyc: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
ostrzyc się: _: perf: subj{np(str)} + {xp(locat)} + {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)}
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)}
osuszać się: _: imperf: 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)}
osuszyć się: _: perf: subj{np(str)} + {prepnp(z,gen)}
oszaleć: _: perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
oszaleć: _: perf: subj{np(str)} + {prepnp(dla,gen)}
oszaleć: _: perf: subj{np(str)} + {prepnp(od,gen)}
oszaleć: _: perf: subj{np(str)} + {prepnp(za,inst)}
oszaleć: _: perf: subj{np(str)} + {prepnp(z,gen)}
oszczędzać: _: imperf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
oszczędzać: _: imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
oszczędzać: _: imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
oszczędzać: _: imperf: subj{np(str)} + {refl}
oszczędzić: _: perf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
oszczędzić: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
oszczędzić: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
oszczędzić: _: perf: subj{np(str)} + {refl}
oszklić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
oszukać się: _: perf: 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)}
oszukiwać się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
oślepiać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
oślepiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oślepić: _: perf: subj{np(str)} + {np(inst)} + {refl}
oślepić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ośmielać: _: 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śmielać się: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
ośmielać się: _: imperf: 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śmielić się: _: perf: subj,controller{np(str)} + controllee{infp(_)}
ośmielić się: _: perf: subj{np(str)} + {prepnp(na,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)} + {or}
oświadczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
oświadczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)}
oświadczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
oświadczyć: _: perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
oświadczyć: _: perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(żeby)}
oświadczyć: _: perf: subj{np(str)} + {prepnp(wobec,gen)} + {or}
oświadczyć się: _: perf: subj{np(str)} + {np(dat)}
oświadczyć się: _: perf: subj{np(str)} + {prepnp(o,acc)}
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)}
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)}
otropić: _: perf: subj{np(str)} + obj{np(str)}
otruć: _: perf: subj{np(str)} + {np(inst)} + {refl}
otruć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otrząsać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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,że)}
otrząsnąć: _: perf: 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,że)}
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)}
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)}
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źwieć: _: perf: subj{np(str)} + {prepnp(z,gen)}
otrzymać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
otrzymać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); 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)}
otrzymywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
otrzymywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otulać: _: perf: subj{np(str)} + {np(inst)} + {refl}
otulać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otulać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
otulać: _: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
otulić: _: perf: subj{np(str)} + {np(inst)} + {refl}
otulić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otulić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
otulić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
otulić: _: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
otworzyć: _: 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)}
otworzyć się: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
otworzyć się: _: perf: subj{np(str)} + {np(dat)}
owiać: _: perf: {np(str)}
owiać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owiewać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owijać: _: 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}
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)}
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}
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)}
owocować: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
ozdabiać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
ozdabiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozdabiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ozdabiać: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ozdobić: _: perf: subj{np(str)} + {np(inst)} + {refl}
ozdobić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozdobić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ozdobić: _: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
oznaczać: _: imperf: subj{infp(_)} + {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(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(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)}
ożenić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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żyć: _: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
ożywać: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
ożywiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ożywiać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
ożywić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ożywić się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnąć: _: imperf: controller{np(dat)} + controllee{infp(_)}
pachnąć: _: imperf: controller{xp(locat)} + controllee{xp(mod)}
pachnąć: _: imperf: {np(inst)} + {xp(locat)}
pachnąć: _: imperf: {prepnp(od,gen)} + {xp(locat)}
pachnąć: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
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(inst)} + {xp(locat)}
pachnieć: _: imperf: {prepnp(od,gen)} + {xp(locat)}
pachnieć: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
pachnieć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnieć: _: imperf: subj{np(str)} + {prepnp(od,gen)}
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)}
palnąć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
palnąć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
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)}
panować: _: imperf: subj{np(str)} + {np(dat)}
panować: _: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
panować: _: imperf: subj{np(str)} + {xp(locat)}
panować: _: imperf: subj{np(str)} + {xp(temp)}
parać się: _: imperf: subj{np(str)} + {np(inst)}
paradować: _: imperf: subj{np(str)} + {xp(locat)}
paradować: _: imperf: subj{np(str)} + {xp(perl)}
parkować: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
parkować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
parować 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)}
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)}
pasać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
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)}
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)}
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ść: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
paść: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
paść: _: perf: {np(dat)} + {prepnp(na,acc)}
paść: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,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)} + {or}
paść: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
paść: _: perf: subj{np(str)} + {prepnp(pod,inst)}
paść: _: perf: subj{np(str)} + {prepnp(z,gen)}
paść się: _: imperf: subj{np(str)} + {np(inst)}
paść się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
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ć: _: 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)}
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)}
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)}
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)}
patyczkować się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
pchnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
pchnąć: _: perf: subj{np(str)} + {np(str)} + {cp(żeby)}
pchnąć: _: perf: subj{np(str)} + {np(str)} + {prepncp(do,gen,żeby)}
pchnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pchnąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pchnąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pełgać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pełnić: _: imperf: subj{np(str)} + obj{np(str)}
penetrować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
perorować: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)}
perorować: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
perorować: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
perorować: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {nonch}
perorować: _: imperf: subj{np(str)} + {np(dat)} + {or}
perorować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
perorować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
perorować: _: imperf: subj{np(str)} + {prepnp(z,inst)}
pertraktować: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
pertraktować: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
pertraktować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
pertraktować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pertraktować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
pertraktować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
pertraktować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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(na,acc)}
pękać: _: imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'szew',natr)}
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)}
piastować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
piąć się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,loc)}
piąć się: _: imperf: subj{np(str)} + {prepnp(ku,dat)}
piąć się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
piąć się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pić: _: imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
pić: _: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
pić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pić: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,jak); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pić: _: imperf: subj{np(str)} + {prepnp(na,acc)}
pić: _: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
piec: _: 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)}
piec się: _: imperf: subj{np(str)}
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)}
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)}
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)}
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)}
pieścić się: _: imperf: subj{np(str)} + {np(inst)}
pieścić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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,że)}
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)}
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)}
pilnować się: _: imperf: subj{np(str)} + {cp(int)}
pilnować się: _: imperf: subj{np(str)} + {cp(żeby)}
pilnować się: _: imperf: subj{np(str)} + {np(gen)}
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)} + {prepnp(na,loc)}
pisać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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}
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)}
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)}
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)}
plamić się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
plamić się: _: imperf: subj{np(str)} + {prepnp(od,gen)}
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}
plątać: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
plątać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
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)}
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)}
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ść się: _: imperf: subj{np(str)}
pleść się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
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ć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
pluć: _: imperf: subj{np(str)} + {prepnp(na,acc)}
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,że)}
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ławić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pławić się: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
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ł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,inst)} + {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)}
pobawić: _: perf: subj{np(str)} + {np(str)}
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)}
pobekiwać: _: perf: subj{np(str)} + {cp(że)}
pobekiwać: _: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
pobić się: _: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
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)}
pobłażać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pobłogosławić: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pobłogosławić: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
pobłogosławić: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
pobłogosławić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
pobłogosławić: _: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {refl}
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)}
pobrudzić się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
pobrudzić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pobrzmiewać: _: imperf: subj{np(str)} + {np(inst)}
pobrzmiewać: _: imperf: 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)}
pobudować się: _: perf: subj{np(str)} + {xp(locat)}
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}
pocałować się: _: perf: subj{np(str)} + {prepnp(z,inst)}
pochodzić: _: imperf: subj{np(str)} + {prepnp(od,gen)}
pochodzić: _: imperf: subj{np(str)} + {xp(abl)}
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)}
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ć: _: 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)}
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)}
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}
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)}
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)}
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)}
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)}
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ąć się: _: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
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)}
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)}
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)}
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}
pocwałować: _: perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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}
począć się: _: perf: subj{np(str)} + {prepnp(w,loc)}
począć się: _: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
poczerwienieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poczerwienieć: _: perf: subj{np(str)} + {prepnp(z,gen)}
poczęstować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poczęstować się: _: perf: subj{np(str)} + {np(inst)}
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(na,loc); prepnp(w,loc)}
poczuć: _: perf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
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)}
poczuwać: _: perf: subj{np(str)} + {prepnp(nad,inst)} + {xp(dur)}
poczuwać: _: perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
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)}
poczynać: _: perf: controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
poczynać: _: perf: subj,controller{E} + controllee{infp(imperf)}
poczynać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poczynać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
poczynać się: _: perf: subj{np(str)} + {prepnp(z,gen)}
poczynić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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ć: _: 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,że)}
podać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
podać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podać: _: perf: subj{np(str)} + {or}
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)}
podarować: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
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,że)}
podawać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
podawać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podawać: _: imperf: subj{np(str)} + {or}
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)}
podążać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst); prepncp(za,inst,int)}
podążać: _: imperf: subj{np(str)} + {prepnp(do,gen)}
podążać: _: imperf: subj{np(str)} + {prepnp(ku,dat)}
podążać: _: imperf: subj{np(str)} + {xp(adl)}
podbić: _: 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)}
podbić się: _: perf: 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)}
podbijać się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
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)}
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)}
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)}
poddawać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
poddawać: _: imperf: subj{np(str)} + {or}
poddawać się: _: imperf: subj{np(str)} + {np(dat)}
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}
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)}
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)}
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)}
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)}
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)}
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)}
poderżnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podglądać: _: imperf: subj{np(str)} + {cp(int)}
podglądać: _: imperf: subj{np(str)} + {cp(jak)}
podglądać: _: imperf: subj{np(str)} + obj{np(str)}
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)}
podjadać: _: imperf: subj{np(str)} + {np(inst)}
podjadać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
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}
podjąć się: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
podjąć się: _: imperf: subj{np(str)} + {cp(że)}
podjąć się: _: imperf: subj{np(str)} + {cp(żeby)}
podjąć się: _: imperf: subj{np(str)} + {np(gen)}
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ć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
podjeżdżać: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podjeżdżać: _: perf: subj{np(str)} + {np(inst)} + {np(str)}
podjeżdżać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podjeżdżać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)}
podjeżdżać: _: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
podjeżdżać: _: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
podjeżdżać: _: perf: subj{np(str)} + {prepnp(ku,dat)}
podjeżdżać: _: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
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)}
podkładać się: _: imperf: subj{np(str)} + {np(dat)}
podkochiwać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
podkreślać: _: imperf: subj{np(str)} + {cp(że)}
podkreślać: _: imperf: subj{np(str)} + obj{ncp(str,int)} + {np(inst)}
podkreślać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
podkreślać: _: imperf: subj{np(str)} + {or}
podkreślić: _: perf: subj{np(str)} + {cp(że)}
podkreślić: _: perf: subj{np(str)} + obj{ncp(str,int)} + {np(inst)}
podkreślić: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
podkreślić: _: perf: subj{np(str)} + {or}
podkuć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podkulać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkulać się: _: imperf: subj{np(str)} + {prepnp(pod,acc)}
podkulić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkulić się: _: perf: subj{np(str)} + {prepnp(pod,acc)}
podkurczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkurczyć się: _: perf: subj{np(str)} + {prepnp(pod,acc)}
podkusić: _: perf: subj,controllee{infp(_)} + controller{np(str)}
podkusić: _: perf: subj{cp(żeby)} + {np(str)}
podkusić: _: perf: subj{cp(że)} + {np(str)}
podkusić: _: perf: subj{np(str)} + controller{np(str)} + controllee{infp(_)}
podkusić: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
podkusić: _: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
podkusić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
podkuwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podlegać: _: imperf: subj{cp(int)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: _: imperf: subj{cp(że)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: _: imperf: subj{np(str)} + {np(dat)}
podlewać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
podlewać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlewać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podłączać: _: 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łączać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączać się: _: imperf: 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łączyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
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łożyć się: _: perf: subj{np(str)} + {np(dat)}
podmyć: _: perf: subj{np(str)} + {np(inst)} + {refl}
podmyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podmywać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
podmywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podnieść: _: 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)}
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)}
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)}
podołać: _: perf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
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)}
podpalić: _: perf: subj{np(str)} + {np(inst)} + {refl}
podpalić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
podpaść się: _: perf: subj{np(str)} + {np(inst)}
podpaść się: _: perf: subj{np(str)} + {prepnp(na,loc)}
podpatrywać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podpatrywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podpatrywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
podpatrywać: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(int)}
podpatrywać: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
podpatrzyć: _: perf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podpatrzyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
podpatrzyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
podpatrzyć: _: perf: subj{np(str)} + {prepnp(u,gen)} + {cp(int)}
podpatrzyć: _: perf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
podpierać: _: 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)}
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)}
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)}
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)}
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)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
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ądkowywać: _: imperf: 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)}
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)}
podprawić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podrabiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)} + {np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
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ć się: _: perf: subj{np(str)} + {prepnp(o,acc)}
podreptać: _: perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
podreptać: _: perf: subj{np(str)} + {prepnp(za,inst)}
podreptać: _: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podrobić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrożeć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,acc)}
podrożyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podróżować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
podróżować: _: imperf: subj{np(str)} + {np(inst)}
podróżować: _: imperf: subj{np(str)} + {prepnp(między,inst)}
podróżować: _: imperf: subj{np(str)} + {prepnp(na,acc)}
podróżować: _: imperf: subj{np(str)} + {xp(abl); xp(adl)}
podróżować: _: imperf: subj{np(str)} + {xp(perl)}
podróżować: _: perf: subj{np(str)} + obj{np(str)}
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)}
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)}
podrzeć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
podrzucać: _: imperf: subj{E} + {np(str)} + {xp(adl)}
podrzucać: _: imperf: subj{np(str)} + {cp(że)}
podrzucać: _: imperf: subj{np(str)} + obj{np(inst)}
podrzucać: _: imperf: subj{np(str)} + obj{np(part)} + {xp(adl)}
podrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podrzucić: _: perf: subj{E} + {np(str)} + {xp(adl)}
podrzucić: _: perf: subj{np(str)} + {cp(że)}
podrzucić: _: perf: subj{np(str)} + obj{np(inst)}
podrzucić: _: perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
podrzucić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podskakiwać: _: imperf: subj{np(str)} + {np(dat)}
podskakiwać: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podskakiwać: _: imperf: subj{np(str)} + {prepnp(do,gen)}
podskakiwać: _: imperf: subj{np(str)} + {prepnp(o,acc)}
podskoczyć: _: perf: subj{np(str)} + {np(dat)}
podskoczyć: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podskoczyć: _: perf: subj{np(str)} + {prepnp(do,gen)}
podskoczyć: _: perf: subj{np(str)} + {prepnp(o,acc)}
podsłuchać: _: imperf: subj{np(str)} + {cp(że)}
podsłuchać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
podsłuchać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podsłuchiwać: _: imperf: subj{np(str)} + {cp(że)}
podsłuchiwać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
podsłuchiwać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podstawiać: _: 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)}
podstawiać się: _: imperf: subj{np(str)} + {np(dat)}
podstawiać się: _: imperf: 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)}
podstawić się: _: perf: subj{np(str)} + {np(dat)}
podstawić się: _: perf: subj{np(str)} + {prepnp(za,acc)}
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ąć: _: 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)}
podsunąć się: _: perf: subj{np(str)} + {prepnp(do,gen)}
podsunąć się: _: perf: 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)}
podsuwać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
podsuwać się: _: imperf: subj{np(str)} + {xp(adl)}
podszyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podszyć się: _: perf: subj{np(str)} + {prepnp(pod,acc)}
podszyć się: _: perf: subj{np(str)} + {prepnp(za,acc)}
podszywać: _: imperf: 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)}
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)}
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)}
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)}
podwyższać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podwyższać się: _: imperf: subj{np(str)} + {prepnp(o,acc)}
podwyższyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podwyższyć się: _: perf: subj{np(str)} + {prepnp(o,acc)}
podyskutować: _: perf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); comprepnp(na temat); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
podyskutować: _: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
podyskutować: _: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
podyskutować: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
podziać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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ł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ć: _: 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)}
podzielić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {or}
podzielić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
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)}
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)}
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)}
pofatygować: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
pofolgować: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pofolgować: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pogadać: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
pogadać: _: perf: subj{np(str)} + {prepnp(do,gen)}
pogadać: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
pogadać: _: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pogadać: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pogadać: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
pogadać: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
poganiać: _: imperf: subj{np(str)} + {np(dat)} + {lexnp(acc,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)}
pogarszać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogarszać się: _: imperf: {np(dat)}
pogarszać się: _: imperf: subj{np(str)} + {np(dat)}
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)}
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ć: _: 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łębiać się: _: imperf: subj{np(str)} + {np(dat)}
pogłębiać się: _: imperf: 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łębić się: _: perf: subj{np(str)} + {np(dat)}
pogłębić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
pogmatwać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pogmatwać się: _: perf: subj{np(str)} + {np(dat)}
pogmatwać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
pognać: _: perf: {np(str)} + {prepnp(do,gen)}
pognać: _: perf: {np(str)} + {xp(abl)} + {xp(adl)}
pognać: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pognać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pognać: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pognić: _: perf: subj{np(str)} + {np(dat)}
pognieść: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pognieść się: _: perf: subj{np(str)} + {np(dat)}
pogodzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
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)}
pogonić: _: perf: {np(str)} + {xp(adl)}
pogonić: _: perf: subj{np(str)} + {np(dat)} + {lexnp(acc,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ć: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogorszyć się: _: perf: {np(dat)}
pogorszyć się: _: perf: subj{np(str)} + {np(dat)}
pogratulować: _: perf: subj{np(str)} + {np(dat)} + {np(gen); cp(że); ncp(gen,że)}
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)}
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}
pogryźć się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pogubić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pogubić się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pogubić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
pohukiwać: _: imperf: subj{np(str)} + {np(inst)}
pohukiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
pohukiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
pohukiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
poinformować: _: 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)}
poinformować się: _: perf: subj{np(str)} + {comprepnp(na temat)} + {xp(locat)}
poinformować się: _: perf: subj{np(str)} + {cp(int)}
poinformować się: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {prepnp(u,gen)}
poinformować się: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {xp(locat)}
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)}
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}
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)}
pojechać: _: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
pojechać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pojechać: _: perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
pojedynkować się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
pojeść: _: perf: subj{np(str)} + {np(inst)} + {lexnp(dat,_,'siebie',natr)}
pojeść: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
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)} + {ncp(str,int)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
pokierować: _: perf: subj{np(str)} + obj{np(inst)}
pokierować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
pokierować: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pokierować się: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
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)}
pokiwać się: _: perf: subj{np(str)}
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)}
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ładać się: _: imperf: subj{np(str)} + {xp(locat)}
pokłócić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,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)}
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)}
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)}
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)}
pokryć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
pokrywać: _: imperf: 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)}
pokrzywdzić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokrzywić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pokrzywić się: _: perf: subj{np(str)} + {np(dat)}
pokrzyżować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pokrzyżować się: _: perf: subj{np(str)} + {np(dat)}
pokrzyżować się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
pokusić się: _: perf: subj,controller{np(str)} + controllee{infp(_)}
pokusić się: _: perf: subj{np(str)} + {cp(żeby)}
pokusić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
pokusić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
pokusić się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
pokutować: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokutować: _: imperf: subj{np(str)} + {prepnp(u,gen)}
pokutować: _: imperf: subj{np(str)} + {prepnp(w,loc)}
pokutować: _: imperf: subj{np(str)} + {prepnp(wśród,gen)}
pokutować: _: imperf: subj{np(str)} + {xp(locat)}
pokwitować: _: perf: subj{np(str)} + {np(inst)} + {cp(że)}
pokwitować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
polać się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
polec: _: perf: subj{np(str)} + {prepnp(od,gen)}
polec: _: perf: subj{np(str)} + {prepnp(za,acc)}
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)}
polecać się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(na,acc,sg,'przyszłość',natr)}
polecić: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
polecić: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
polecić: _: imperf: subj{np(str)} + {np(dat)} + {or}
polecić: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
polecić: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
polecić: _: imperf: subj{np(str)} + obj,controllee{np(str); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)}
polecić: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
polecić: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
polecić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
polecić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
polecić się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(na,acc,sg,'przyszłość',natr)}
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)}
polemizować: _: imperf: subj{np(str)} + {cp(int)}
polemizować: _: imperf: subj{np(str)} + {cp(że)}
polemizować: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
polemizować: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
polemizować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
polemizować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
polemizować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
polemizować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
polepszać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
polepszać się: _: imperf: {np(dat)}
polepszać się: _: imperf: subj{np(str)} + {np(dat)}
polepszyć: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
polepszyć się: _: perf: {np(dat)}
polepszyć się: _: perf: subj{np(str)} + {np(dat)}
polerować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polewać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
polewać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
polewać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polewać: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
poleżeć: _: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
policzyć: _: perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc); 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)}
policzyć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
polować: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
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)}
polubić się: _: perf: subj{np(str)} + {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łamać się: _: perf: subj{np(str)} + {np(dat)}
połamać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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ł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łą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łą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ł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ł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{infp(imperf)}
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łożyć się: _: perf: subj,controller{np(str)} + controllee{infp(imperf)}
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łyskiwać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pomachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
pomachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
pomachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pomachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pomachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pomachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
pomachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
pomachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
pomachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
pomagać: _: imperf: subj{cp(że)} + {np(dat)}
pomagać: _: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
pomagać: _: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
pomagać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pomagać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pomagać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
pomagać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
pomarszczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomarszczyć się: _: perf: subj{np(str)} + {np(dat)}
pomarzyć: _: perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
pomarzyć: _: perf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
pomarzyć: _: perf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {lexnp(dat,_,'siebie',natr)}
pomaszerować: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pomiaukiwać: _: imperf: subj{np(str)}
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)}
pomieszać się: _: perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
pomieszać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pomieścić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pomieścić się: _: perf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: _: perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: _: perf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: _: perf: subj{ncp(str,int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: _: perf: subj{ncp(str,żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: _: perf: subj{ncp(str,że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: _: perf: subj{np(str)} + {xp(locat)}
pomodlić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {or}
pomodlić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {cp(żeby)}
pomodlić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,inst)} + {cp(żeby)}
pomóc: _: perf: subj{cp(że)} + {np(dat)}
pomóc: _: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
pomóc: _: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
pomóc: _: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pomóc: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pomóc: _: perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
pomóc: _: perf: subj{np(str)} + {prepnp(na,acc)}
pomścić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
pomścić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
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)}
pomyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomyć: _: perf: subj{np(str)} + {refl}
pomylić: _: perf: subj{np(str)} + {np(dat)} + {np(str)}
pomylić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
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}
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)}
ponawiać: _: imperf: subj{np(str)} + obj{np(str)}
ponawiać się: _: imperf: subj{np(str)}
poniechać: _: perf: subj{np(str)} + obj{np(gen)}
ponieść: _: perf: {np(str)} + {xp(adl)}
ponieść: _: perf: subj{np(str)} + {np(str)}
ponieść: _: perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'ręka',ratr)}
ponieść: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ponieść: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
poniewierać: _: imperf: subj{np(str)} + obj{np(inst)}
poniewierać: _: imperf: subj{np(str)} + obj{np(str)}
poniewierać się: _: imperf: subj{np(str)} + {xp(locat)}
ponowić: _: perf: subj{np(str)} + obj{np(str)}
ponowić się: _: perf: subj{np(str)}
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)}
poobijać się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
poobijać się: _: perf: subj{np(str)} + {xp(locat)}
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}
pooglądać się: _: perf: subj{np(str)} + {prepnp(za,inst)}
popadać: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {preplexnp(w,acc,sg,'niełaska',natr)}
popadać: _: imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
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)}
popaść się: _: perf: subj{np(str)} + {np(inst)}
popaść się: _: perf: subj{np(str)} + {prepnp(na,loc)}
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)}
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)}
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)}
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)}
popełniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popełnić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
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}
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)}
popijać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popijać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
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)}
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ć: _: perf: subj{np(str)} + {np(inst)} + {refl}
poplamić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poplamić się: _: perf: subj{np(str)} + {prepnp(od,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ł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ł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ć: _: imperf: subj{np(str)} + {np(inst); prepnp(na,loc)} + {xp(dur)} + {xp(perl)}
popływać: _: imperf: subj{np(str)} + {xp(locat)}
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)}
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}
poprzedzić: _: perf: subj{ncp(str,że)} + obj{np(str)}
poprzedzić: _: perf: subj{np(str)} + obj{np(str)} + {np(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)}
popsuć: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
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)}
popychać: _: imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
popychać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
popychać: _: imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,że)}
popychać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pora: _: imperf: controller{np(dat)} + controllee{infp(_)}
pora: _: imperf: {cp(żeby)}
pora: _: imperf: {prepnp(na,acc); prepncp(na,acc,żeby)}
pora: _: imperf: {xp(adl)}
porabiać: _: imperf: subj{np(str)} + {nonch} + {xp(dur)}
porabiać: _: imperf: subj{np(str)} + {nonch} + {xp(locat)}
porać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
poradzić: _: 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)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
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)}
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)}
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)}
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)}
porównać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int)}
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}
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)}
poruszać: _: perf: subj{np(str)} + {np(inst)} + {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ć 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)}
poruszyć się: _: perf: subj{np(str)}
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)}
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)}
porykiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
porykiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
porykiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
porykiwać: _: imperf: subj{np(str)} + {prepnp(o,loc)}
porykiwać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
porywać: _: 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)}
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)}
porządkować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porządkować się: _: imperf: subj{np(str)}
porzucać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
porzucać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porzucać: _: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
porzucać: _: perf: subj{np(str)} + {np(str)} + {xp(adl)}
porzucić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
porzucić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
posadzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
posadzić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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}
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)}
posiać się: _: perf: subj{np(str)} + {xp(locat)}
posiadać: _: imperf: subj{np(str)} + {np(str)}
posiadać: _: imperf: subj{np(str)} + obj{np(str)}
posiadać: _: perf: subj{np(str)} + {xp(locat)}
posiadać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
posiąść: _: perf: subj{np(str)} + {np(str)}
posiąść się: _: perf: subj{np(str)} + {prepnp(z,gen)}
posilać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
posilać się: _: imperf: subj{np(str)} + {np(inst)}
posilić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
posilić się: _: perf: subj{np(str)} + {np(inst)}
posiwieć: _: perf: subj{np(str)} + {np(dat)}
posiwieć: _: perf: subj{np(str)} + {xp(locat)}
posiwieć: _: perf: {xp(locat)}
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)}
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}
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)}
poskramiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
poskręcać: _: perf: {np(str)} + {prepnp(z,gen)}
poskręcać: _: perf: {np(str)} + {xp(locat)}
poskręcać: _: perf: obj{cp(gdy)} + {np(str)}
poskręcać: _: perf: obj{cp(jak)} + {np(str)}
poskręcać: _: perf: obj{cp(kiedy)} + {np(str)}
poskręcać: _: perf: obj{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)}
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)}
poskromić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)} + {or}
posłać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
posłać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
posłać: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
posłuchać: _: imperf: subj{np(str)} + {cp(int)}
posłuchać: _: imperf: subj{np(str)} + {cp(że)}
posłuchać: _: imperf: subj{np(str)} + {np(gen); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
posłuchać: _: imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
posłuchać: _: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)} + {np(inst)}
posłuchać się: _: imperf: subj{np(str)} + {np(gen)}
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ługiwać się: _: imperf: 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łużyć się: _: perf: subj{np(str)} + {np(inst)}
posłyszeć: _: perf: subj{np(str)} + {cp(int)}
posłyszeć: _: perf: subj{np(str)} + {cp(jak)}
posłyszeć: _: perf: subj{np(str)} + {cp(że)}
posłyszeć: _: perf: subj{np(str)} + obj{np(str)}
posłyszeć: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
posmakować: _: perf: subj{np(str)} + {cp(int)}
posmakować: _: perf: subj{np(str)} + {np(dat)}
posmakować: _: perf: subj{np(str)} + obj{np(gen); ncp(gen,int)}
posmutnieć: _: perf: subj{np(str)} + {cp(że)}
posmutnieć: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
posmutnieć: _: perf: subj{np(str)} + {or}
posolić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
posolić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
posolić: _: perf: subj{np(str)} + {refl}
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)}
pospieszyć się: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)}
pospieszyć się: _: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
postanawiać: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
postanawiać: _: imperf: subj{np(str)} + obj{cp(int)}
postanawiać: _: imperf: subj{np(str)} + obj{cp(że)}
postanawiać: _: imperf: subj{np(str)} + obj{cp(żeby)}
postanawiać: _: imperf: subj{np(str)} + obj{np(str)}
postanawiać: _: imperf: subj{np(str)} + {or}
postanawiać: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
postanowić: _: perf: subj,controller{np(str)} + controllee{infp(_)}
postanowić: _: perf: subj{np(str)} + obj{cp(int)}
postanowić: _: perf: subj{np(str)} + obj{cp(że)}
postanowić: _: perf: subj{np(str)} + obj{cp(żeby)}
postanowić: _: perf: subj{np(str)} + obj{np(str)}
postanowić: _: perf: subj{np(str)} + {or}
postanowić: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
postarać się: _: perf: subj,controller{np(str)} + controllee{prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby); infp(_)}
postawić: _: 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)}
postawić: _: perf: subj{np(str)} + {prepnp(za,acc)} + {infp(_)} + {lexnp(dat,_,'siebie',natr)}
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)}
postękiwać: _: imperf: subj{np(str)} + {cp(że)}
postękiwać: _: imperf: subj{np(str)} + {or}
postękiwać: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
postękiwać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
postępować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(wobec,gen)}
postępować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(względem,gen)}
postępować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
postępować: _: imperf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
postępować: _: imperf: subj{np(str)} + {np(inst)}
postępować: _: imperf: subj{np(str)} + {np(str)} + {prepnp(za,inst)}
postępować: _: imperf: subj{np(str)} + {np(str)} + {xp(adl)}
postępować: _: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(za,inst)}
postępować: _: imperf: subj{np(str)} + {prepnp(według,gen)}
postrzępić: _: 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)}
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)}
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ąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
posunąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
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)}
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)}
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)}
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)}
posypać się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
posypać się: _: perf: subj{np(str)} + {prepnp(na,acc)}
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)}
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)}
poszerzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int)}
poszerzać się: _: imperf: 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)}
poszerzyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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(locat)}
poszybować: _: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
pościelić: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pościelić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poślinić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poślizgnąć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
pośliznąć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
poś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ś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ś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ś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ć: _: 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ęcać się: _: imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
poświęcać się: _: imperf: 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ś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)}
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ł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ł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łumić: _: perf: subj{np(str)} + obj{np(str)}
potopić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
potopić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
potrafić: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
potrafić: _: imperf: subj{np(str)} + {nonch}
potrajać: _: imperf: subj{np(str)} + obj{np(str)}
potrącić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potrącić: _: perf: subj{np(str)} + obj{lexnp(str,sg,'struna',atr)} + {prepnp(u,gen)}
potrącić: _: perf: subj{np(str)} + obj{lexnp(str,sg,'struna',atr)} + {prepnp(w,loc)}
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)}
potrzaskiwać: _: imperf: subj{np(str)} + {np(inst)}
potrzaskiwać: _: imperf: subj{np(str)} + {xp(locat)}
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)}
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}
potwierdzać się: _: imperf: subj{cp(że)}
potwierdzać się: _: imperf: subj{np(str); ncp(str,że)}
potwierdzać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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}
potwierdzić się: _: perf: subj{cp(że)}
potwierdzić się: _: perf: subj{np(str); ncp(str,że)}
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ć: _: 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)}
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)}
poukładać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
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)}
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)} + {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)}
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)}
powalać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powalać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
powalać się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
powalać się: _: imperf: subj{np(str)} + {xp(adl)}
powalać się: _: perf: subj{np(str)} + {np(inst)}
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)}
powalić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
powalić się: _: perf: subj{np(str)} + {xp(adl)}
poważnieć: _: imperf: subj{np(str)} + {np(dat)}
powąchać: _: perf: subj{np(str)} + {cp(int)} + {refl}
powąchać: _: perf: subj{np(str)} + {lexnp(str,pl,'kwiatek',natr)} + {preplexnp(od,gen,sg,'spód',natr)}
powąchać: _: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
powąchać: _: perf: subj{np(str)} + obj{np(str); cp(int)} + {np(dat)}
powątpiewać: _: imperf: subj{np(str)} + {cp(int)}
powątpiewać: _: imperf: subj{np(str)} + {cp(że)}
powątpiewać: _: imperf: subj{np(str)} + {cp(żeby)}
powątpiewać: _: imperf: subj{np(str)} + {or}
powątpiewać: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
powątpiewać: _: imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
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)}
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}
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)} + {or}
powiadomić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
powierzać: _: imperf: subj{np(str)} + {np(dat)} + {refl}
powierzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
powierzać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)}
powierzać: _: imperf: subj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)} + {refl}
powierzyć: _: perf: subj{np(str)} + {np(dat)} + {refl}
powierzyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powierzyć: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)}
powierzyć: _: perf: subj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)} + {refl}
powieść: _: 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)}
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)}
powiększać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
powiększać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
powiększać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powiększyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powiększyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
powiększyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powinien: _: imperf: subj,controller{E} + controllee{infp(_)}
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)}
powitać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
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)}
powlekać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
powlekać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
powlekać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
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)} + {np(inst); ncp(inst,że)} + {xp(locat)}
powodować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
powołać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powołać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powołać się: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
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)}
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ć: _: imperf: subj{np(str)} + {np(dat)}
powstawać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powstawać: _: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
powstawać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
powstawać: _: perf: subj{np(str)} + {prepnp(z,gen)}
powstydzić się: _: perf: subj,controller{np(str)} + controllee{infp(_)}
powstydzić się: _: perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(przed,inst)}
powstydzić się: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
powstydzić się: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
powstydzić się: _: perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
powtarzać: _: 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)}
powtarzać się: _: imperf: 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)}
powtórzyć się: _: perf: subj{np(str)}
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)}
powziąć: _: perf: subj{np(str)} + obj{np(str)}
pozabijać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pozabijać się: _: perf: subj{np(str)} + {prepnp(o,acc)}
pozazdrościć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
pozazdrościć: _: perf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,int); ncp(gen,że)}
pozbawiać: _: imperf: subj{np(str)} + {np(gen)} + {refl}
pozbawiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(gen)}
pozbawić: _: perf: subj{np(str)} + {np(gen)} + {refl}
pozbawić: _: perf: subj{np(str)} + obj{np(str)} + {np(gen)}
pozbawić się: _: perf: subj{np(str)} + {np(gen)}
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)}
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)}
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)}
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)}
poznać się: _: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
poznać się: _: perf: 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)}
poznawać się: _: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
poznawać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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ć: _: 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)}
pozostawać: _: perf: subj,controller{np(str)} + controllee{np(inst)}
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)}
pozostawiać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)}
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)}
pozwalać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozwalać: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
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)}
pożalić się: _: perf: subj{np(str)} + {np(dat)} + {cp(int)}
pożalić się: _: perf: subj{np(str)} + {np(dat)} + {cp(jak)}
pożalić się: _: perf: subj{np(str)} + {np(dat)} + {or}
pożalić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
pożalić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pożalić się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
pożalić się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
pożalić się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
pożalić się: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
pożalić się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
pożalić się: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
pożałować: _: perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
pożałować: _: perf: subj{np(str)} + {np(gen); cp(że); ncp(gen,że)}
pożałować: _: perf: subj{np(str)} + {np(gen)} + {or}
pożądać: _: imperf: subj{np(str)} + obj{np(gen)}
pożegnać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pożegnać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pożerać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pożreć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pożreć się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pożyczać: _: imperf: subj{np(str)} + {np(part)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczać: _: imperf: subj{np(str)} + {np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
pożyczać: _: imperf: subj{np(str)} + obj{np(part)} + {prepnp(od,gen)}
pożyczać: _: imperf: subj{np(str)} + obj{np(part)} + {prepnp(u,gen)}
pożyczać: _: imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
pójść: _: perf: controller{np(dat)} + controllee{xp(mod)}
pójść: _: perf: {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr); preplexnp(w,acc,pl,'noga',natr)}
pójść: _: perf: {np(dat)} + {preplexnp(w,acc,pl,'pięta',natr)}
pójść: _: perf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
pójść: _: perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
pójść: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pójść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
pójść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ręka',natr)}
pójść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'zdrowie',natr)}
pójść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'noga',natr)}
pójść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'pięta',natr)}
pójść: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pójść: _: perf: subj{np(str)} + {preplexnp(w,acc,pl,'ślad',ratr)}
pójść: _: perf: subj{np(str)} + {preplexnp(z,inst,pl,'torba',natr)}
pójść: _: perf: subj{np(str)} + {preplexnp(z,inst,sg,'dym',natr)}
pójść: _: perf: subj{np(str)} + {prepnp(do,gen)}
pójść: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pójść: _: perf: subj{np(str)} + {prepnp(po,acc)}
pójść: _: perf: subj{np(str)} + {prepnp(w,acc)}
pójść: _: perf: subj{np(str)} + {prepnp(za,acc)}
pójść: _: perf: subj{np(str)} + {prepnp(za,inst)}
pójść: _: perf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,acc,sg,'ogień',natr)}
pójść: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)} + {preplexnp(o,acc,sg,'zakład',natr)}
pójść: _: perf: subj{np(str)} + {prepnp(z,inst)} + {fixed('na udry')}
pójść: _: perf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'łóżka',natr)}
pójść: _: perf: subj{np(str)} + {xp(adl)}
pójść: _: perf: subj{np(str)} + {xp(perl)}
pracować: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
pracować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
pracować: _: imperf: subj{np(str)} + {comprepnp(na rzecz)}
pracować: _: imperf: subj{np(str)} + {prepnp(dla,gen)}
pracować: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pracować: _: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
pracować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
pracować: _: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
pracować: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
pracować: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
pragnąć: _: imperf: subj,controller{np(str)} + controllee{cp(żeby); infp(_)}
pragnąć: _: imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
praktykować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)}
praktykować: _: imperf: subj{np(str)} + {prepnp(u,gen)}
praktykować: _: imperf: subj{np(str)} + {prepnp(w,loc)}
praktykować: _: imperf: subj{np(str)} + {xp(locat)}
prasować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
prątkować: _: imperf: subj{np(str)} + {np(inst)}
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}
precyzować się: _: imperf: subj{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)}
pretendować: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
prężyć: _: imperf: subj{np(str)} + obj{np(str)}
prężyć się: _: imperf: subj{np(str)}
produkować: _: imperf: subj{np(str)} + obj{np(str)}
produkować się: _: imperf: subj{np(str)} + {comprepnp(na temat)}
produkować się: _: imperf: subj{np(str)} + {or}
produkować się: _: imperf: subj{np(str)} + {xp(locat)}
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,inst)}
programować: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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)}
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ć: _: 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)}
promować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
promować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
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ć: _: imperf: {np(gen)}
prosić: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
prosić: _: imperf: subj{np(str)} + obj{np(str)} + {or}
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ć się: _: imperf: subj{np(str)} + {cp(żeby)}
prosić się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
prosperować: _: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
protestować: _: imperf: subj{np(str)} + {cp(że)}
protestować: _: imperf: subj{np(str)} + {cp(żeby)}
protestować: _: imperf: subj{np(str)} + {or}
protestować: _: imperf: subj{np(str)} + {prepncp(przeciw,dat,jakoby)}
protestować: _: imperf: subj{np(str)} + {prepncp(przeciw,dat,żeby)}
protestować: _: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że)}
prowadzić: _: 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)}
prowadzić się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
prowokować: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {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)}
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óbować się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
próżnować: _: imperf: subj{np(str)}
prywatyzować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
prywatyzować się: _: imperf: subj{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,ż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,ż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ć: _: 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)}
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)}
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}
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)}
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)}
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)}
przebiec się: _: perf: subj{np(str)} + {prepnp(po,loc)}
przebiec się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
przebiegać: _: perf: subj{np(str)} + obj{np(str)}
przebiegać się: _: imperf: subj{np(str)} + {prepnp(po,loc)}
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ć: _: 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)}
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)}
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)}
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)}
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)}
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)}
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)}
przebywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebywać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)} + {xp(locat)}
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}
przeceniać się: _: imperf: 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}
przecenić się: _: perf: subj{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)}
przechodzić: _: perf: subj{np(str)} + obj{np(str)}
przechwalać: _: imperf: subj{np(str)} + obj{np(str)}
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}
przechwycić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przechwycić: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przechylać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przechylać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przechylać się: _: imperf: subj{np(str)} + {prepnp(przez,acc)}
przechylać się: _: imperf: 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)}
przechylić się: _: perf: subj{np(str)} + {prepnp(przez,acc)}
przechylić się: _: perf: subj{np(str)} + {xp(adl)}
przeciąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przeciąć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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ągać się: _: imperf: 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ągnąć się: _: perf: subj{np(str)} + {xp(dur)}
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)}
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)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przecinać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
przeciskać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przeciskać się: _: imperf: 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)}
przecisnąć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przecisnąć się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeciwdziałać: _: imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
przeciwstawiać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przeciwstawiać się: _: imperf: 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)}
przeciwstawić się: _: perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
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)}
przeczesywać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
przeczesywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeczesywać się: _: imperf: subj{np(str)} + {xp(perl)}
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}
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ć: _: 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)}
przećwiczyć się: _: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
przedkładać: _: imperf: subj{np(str)} + {cp(że); cp(żeby)}
przedkładać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
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)}
przedkładać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,acc)}
przedostać się: _: perf: subj{cp(że)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostać się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostawać się: _: imperf: subj{cp(że)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostawać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedrzeć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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źniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
przedrzeźniać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
przedsiębrać: _: imperf: subj{np(str)} + {infp(_)}
przedsiębrać: _: imperf: subj{np(str)} + obj{np(str)}
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)}
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)}
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)}
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)}
przedzierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)}
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)}
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)}
przegryzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przegryzać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {xp(adl)}
przegryzać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
przegryźć: _: perf: 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)}
przeinaczać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeinaczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
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)}
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)}
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)}
przejawiać: _: imperf: subj{np(str)} + obj{np(str)}
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)}
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)}
przejąć się: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przejechać: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przejechać: _: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przejechać: _: perf: subj{np(str)} + {np(str)} + {xp(perl)}
przejechać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przejechać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przejechać się: _: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
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)}
przejmować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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ć się: _: perf: subj{np(str)} + {prepnp(do,gen)}
przejrzeć się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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{infp(_)} + {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)}
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)}
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)}
przekląć: _: perf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
przekląć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,że)}
przekląć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
przekląć: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
przekląć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
przekląć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przekląć: _: perf: subj{np(str)} + obj{np(str)} + {or}
przeklinać: _: imperf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
przeklinać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,że)}
przeklinać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
przeklinać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
przeklinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
przeklinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przeklinać: _: imperf: subj{np(str)} + obj{np(str)} + {or}
przekonać: _: 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)}
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)}
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}
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)}
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)}
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)}
przekraczać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekraczać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
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)}
przekroczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekroczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
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}
przekrzyczeć się: _: perf: 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}
przekrzykiwać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przekształcać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + {prepadjp(z,gen)}
przekształcać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + {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łcać się: _: imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {prepadjp(z,gen)}
przekształcać się: _: imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + {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)}
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)}
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)}
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)}
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ć: _: 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)}
przelecieć się: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelecieć się: _: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
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)}
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)}
przełknąć: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
przełykać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
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)}
przemawiać się: _: imperf: subj{np(str)} + {or}
przemawiać się: _: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
przemęczać: _: imperf: subj{np(str)} + {np(inst)} + {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ęczyć: _: perf: subj{np(str)} + {np(inst)} + {np(str)}
przemęczyć: _: perf: subj{np(str)} + {np(str)} + {xp(locat)}
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)}
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)}
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)}
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)}
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)}
przemieszczać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przemieszczać się: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przemijać: _: perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
przemijać: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przeminąć: _: perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
przeminąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,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(w,loc)}
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ó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)}
przemówić się: _: perf: subj{np(str)} + {prepnp(z,inst)}
przemyśleć: _: perf: subj{np(str)} + {cp(int)}
przemyśleć: _: perf: subj{np(str)} + {cp(że)}
przemyśleć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
przenikać się: _: imperf: 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)}
przeniknąć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
przeobrazić się: _: perf: subj,controller{np(str)} + controllee{prepnp(w,acc)} + controllee{prepnp(z,gen)}
przeobrazić się: _: perf: 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)}
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)}
przeoczyć: _: perf: subj{np(str)} + obj{cp(int)}
przeoczyć: _: perf: subj{np(str)} + obj{cp(jak)}
przeoczyć: _: perf: subj{np(str)} + obj{cp(że)}
przeoczyć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
przepadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepadać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przepadać: _: imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
przepadać: _: imperf: subj{np(str)} + {prepncp(za,inst,żeby2)}
przepadać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
przepadać: _: imperf: subj{np(str)} + {prepnp(w,loc)}
przepadać: _: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,gdy); prepncp(za,inst,int); prepncp(za,inst,jak); prepncp(za,inst,kiedy); prepncp(za,inst,że)}
przepaść: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepaść: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przepaść: _: perf: subj{np(str)} + {np(dat)} + {xp(temp)}
przepaść: _: perf: subj{np(str)} + {prepnp(na,loc)}
przepaść: _: perf: subj{np(str)} + {prepnp(w,loc)}
przepełniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepełniać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przepełnić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepełnić się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
przepędzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepędzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przepędzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przepędzać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepędzić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przepędzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przepędzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przepędzić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepisać: _: 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)}
przepisać się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisać się: _: perf: 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)}
przepisywać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisywać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
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)}
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)}
przepłynąć: _: perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(przez,acc)}
przepłynąć się: _: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
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ławiać się: _: imperf: 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)}
przepołowić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepowiadać: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przepowiadać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przepowiadać: _: imperf: subj{np(str)} + {np(dat)} + {or}
przepowiadać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przepowiedzieć: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przepowiedzieć: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przepowiedzieć: _: imperf: subj{np(str)} + {np(dat)} + {or}
przepowiedzieć: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przepracować: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepracować się: _: perf: subj{np(str)} + {np(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)}
przepraszać się: _: imperf: 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}
przeprosić się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
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)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
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)}
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)}
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ć: _: perf: subj{np(str)} + {np(dat)} + {or}
przerwać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przerwać się: _: perf: subj{np(str)}
przerywać: _: imperf: subj{np(str)} + {np(dat)} + {or}
przerywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przerywać się: _: imperf: subj{np(str)}
przerzucać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(nad,inst)}
przerzucać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przerzucać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucać: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerzucać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przerzucać się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucać 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)}
przerzucić się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucić się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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ądzić: _: perf: subj{np(str)} + {cp(żeby)}
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); ncp(str,że)} + obj{np(str); ncp(str,że)}
przesądzić: _: perf: subj{np(str)} + obj{cp(że)}
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)}
przesiać się: _: perf: subj{np(str)} + {prepnp(przez,acc)}
przesiadać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przesiadać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przesiadać się: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przesiadać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiadywać: _: imperf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
przesiadywać: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {xp(dur)}
przesiadywać: _: imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przesiadywać: _: imperf: subj{np(str)} + {xp(dur)} + {xp(locat)} + {lexnp(inst,sg,'kamień',natr)}
przesiąkać: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesiąkać: _: imperf: subj{np(str)} + {np(inst)}
przesiąknąć: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przesiąknąć: _: perf: subj{np(str)} + {np(inst)}
przesiąść się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przesiąść się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przesiąść się: _: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przesiąść się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiedzieć: _: perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
przesiedzieć: _: perf: subj{np(str)} + {prepnp(u,gen)} + {xp(dur)}
przesiedzieć: _: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przesiewać: _: 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)}
przesiewać się: _: imperf: subj{np(str)} + {prepnp(przez,acc)}
przesłać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przesłać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
przesłać: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesłaniać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
przesłonić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
przesłuchać: _: perf: subj{np(str)} + obj{np(str)}
przesłuchiwać: _: imperf: subj{np(str)} + obj{np(str)}
przespać: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przespać się: _: perf: subj{np(str)} + {prepnp(z,inst)}
przespać się: _: perf: subj{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)}
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)}
przestraszyć: _: perf: subj{cp(że)} + {np(str)}
przestraszyć: _: perf: subj{np(str); ncp(str,że)} + 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)}
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}
przesuwać: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
przesuwać: _: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
przesuwać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesuwać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesycać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesycać się: _: imperf: subj{np(str)} + {np(inst)}
przesycić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesycić się: _: perf: subj{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)}
przeszczepiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przeszczepiać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przeszczepić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przeszczepić się: _: perf: subj{np(str)} + {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)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
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)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przeszukać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeszukiwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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ś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ś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ścignąć się: _: perf: subj{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ś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świetlać się: _: imperf: 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świetlić się: _: perf: subj{np(str)} + {np(dat)}
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)}
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)}
przetrwać: _: perf: subj{np(str)} + obj{np(str)}
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)}
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)}
przetykać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetykać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
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}
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ć: _: 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)}
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)}
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)}
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)}
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ć: _: 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)}
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)}
przewrócić: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'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)}
przewrócić się: _: perf: {np(dat)} + {preplexnp(w,loc,pl,'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)}
przewyższać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przewyższać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
przewyższać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
przewyższyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przewyższyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
przewyższyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
przeziębić: _: perf: subj{np(str)} + obj{np(str)}
przeziębić się: _: perf: subj{np(str)}
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)}
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}
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żyć się: _: perf: 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)}
przeżywać się: _: imperf: subj{np(str)}
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)} + obj{refl} + {prepnp(w,acc)}
przybierać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
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)}
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ż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ż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)}
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)}
przybrać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przybrać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przybrać: _: perf: subj{np(str)} + {prepnp(na,loc)}
przybrać: _: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przybyć: _: perf: {np(dat)} + {np(gen)}
przybyć: _: perf: {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybyć: _: perf: {np(gen)} + {xp(locat)}
przybyć: _: perf: subj{np(str)} + {np(dat)}
przybyć: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybyć: _: perf: subj{np(str)} + {prepnp(na,acc)}
przybyć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przybyć: _: perf: subj{np(str)} + {xp(locat)}
przybywać: _: imperf: {np(dat)} + {np(gen)}
przybywać: _: imperf: {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybywać: _: imperf: {np(gen)} + {xp(locat)}
przybywać: _: imperf: subj{np(str)} + {np(dat)}
przybywać: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybywać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przybywać: _: imperf: subj{np(str)} + {xp(locat)}
przychodzić: _: imperf: subj,controllee{infp(_)} + controller{np(dat)}
przychodzić: _: imperf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(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{infp(_)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',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(do,gen)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
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)}
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)}
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,żeby)}
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)} + {xp(adl)}
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)} + {xp(adl)}
przycichnąć: _: perf: {prepnp(o,loc); prepncp(o,loc,że)} + {xp(locat)}
przycichnąć: _: perf: subj{np(str)} + {xp(locat)}
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)}
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)}
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)}
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)}
przyczyniać: _: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
przyczyniać się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
przyczynić: _: perf: subj{np(str)} + {np(dat)} + {np(gen)} + {np(inst)}
przyczynić się: _: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
przygasać: _: imperf: subj{np(str)}
przygasnąć: _: perf: subj{np(str)}
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)}
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)}
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)}
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)}
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)}
przygryzać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przygryzać: _: imperf: subj{np(str)} + {np(dat)} + {or}
przygryzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
przygryźć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przygryźć: _: perf: subj{np(str)} + {np(dat)} + {or}
przygryźć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
przygważdżać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przygwoździć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyjaźnić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
przyjąć: _: 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)} + {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)} + {prepnp(za,inst)}
przyjąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {xp(temp)}
przyjąć się: _: perf: {infp(imperf)}
przyjąć się: _: perf: 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)} + {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)} + {prepnp(za,inst)}
przyjmować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {xp(temp)}
przyjmować się: _: imperf: {infp(imperf)}
przyjmować się: _: imperf: subj{np(str)}
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(do,gen)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
przyjść: _: perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
przyjść: _: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
przyjść: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przyjść: _: perf: subj{np(str)} + {xp(adl)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
przykazać: _: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
przykazać: _: perf: subj{np(str)} + {np(dat)} + {advp(pron)}
przykazać: _: perf: subj{np(str)} + {np(dat)} + {or}
przykazać: _: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
przykazać: _: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przykazać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przykleić: _: 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)}
przykleić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przykleić się: _: perf: 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)}
przyklejać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyklejać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
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)}
przykładać się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przykręcać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(na,acc)}
przykręcić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(na,acc)}
przykryć: _: perf: subj{np(str)} + {np(inst)} + {refl}
przykryć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przykuć: _: perf: subj{np(str); ncp(str,jak); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przykuć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przykuć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przykuwać: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przykuwać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przykuwać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
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łapać się: _: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przyłączać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyłączać się: _: imperf: subj{np(str)} + {prepncp(do,gen,że)}
przyłączać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
przyłączyć: _: perf: 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ł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)}
przyłożyć się: _: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
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)}
przymknąć się: _: perf: subj{np(str)} + {np(dat)}
przymocować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,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ć: _: 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)}
przymykać się: _: imperf: subj{np(str)} + {np(dat)}
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)}
przypadać: _: imperf: subj,controllee{infp(_)} + controller{np(dat)}
przypadać: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'udział',natr)}
przypadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przypadać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
przypadać: _: imperf: subj{np(str)} + {xp(temp)}
przypaść: _: perf: subj,controllee{np(str)} + controller{infp(_)}
przypaść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'udział',natr)}
przypaść: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przypaść: _: perf: subj{np(str)} + {prepnp(na,acc)}
przypaść: _: perf: subj{np(str)} + {xp(temp)}
przypatrywać się: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przypatrywać się: _: imperf: subj{np(str)} + {np(dat)} + {cp(jak)}
przypatrywać się: _: imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przypatrzeć się: _: perf: subj{np(str)} + {np(dat)} + {cp(int)}
przypatrzeć się: _: perf: subj{np(str)} + {np(dat)} + {cp(jak)}
przypatrzeć się: _: perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
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)}
przypiąć się: _: perf: subj{np(str)} + {prepnp(do,gen)}
przypieczętować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
przypinać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
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}
przypodobać się: _: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
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}
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)}
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}
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)}
przypuszczać: _: imperf: subj{np(str)} + {advp(pron)}
przypuszczać: _: imperf: subj{np(str)} + {cp(int)}
przypuszczać: _: imperf: subj{np(str)} + {cp(że)}
przypuszczać: _: imperf: subj{np(str)} + {cp(żeby2)}
przypuszczać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypuszczać: _: imperf: subj{np(str)} + {or}
przypuścić: _: perf: subj{np(str)} + {advp(pron)}
przypuścić: _: perf: subj{np(str)} + {cp(int)}
przypuścić: _: perf: subj{np(str)} + {cp(że)}
przypuścić: _: perf: subj{np(str)} + {cp(żeby2)}
przypuścić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypuścić: _: perf: subj{np(str)} + {or}
przyrównać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyrównać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przyrównywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyrównywać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przyrządzać: _: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przyrządzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przyrządzić: _: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przyrządzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
przyrzec: _: perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
przyrzec: _: perf: subj{np(str)} + {np(dat)} + {or}
przyrzec: _: perf: subj{np(str)} + obj{np(dat)} + {cp(że)}
przyrzec: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przyrzekać: _: perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
przyrzekać: _: perf: subj{np(str)} + {np(dat)} + {or}
przyrzekać: _: perf: subj{np(str)} + obj{np(dat)} + {cp(że)}
przyrzekać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
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ąc się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
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ąść się: _: perf: subj{np(str)} + {prepnp(do,gen)}
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ęgać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
przysłać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysłać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
przysłaniać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przysłaniać: _: imperf: subj{np(str)} + {np(inst)} + {refl}
przysłaniać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
przysłonić: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przysłonić: _: perf: subj{np(str)} + {np(inst)} + {refl}
przysłonić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
przysłuchiwać się: _: imperf: subj{np(str)} + {cp(int)}
przysłuchiwać się: _: imperf: subj{np(str)} + {cp(jak)}
przysłuchiwać się: _: imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przysługiwać: _: imperf: subj{np(str)} + {np(dat)}
przysłużyć się: _: perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
przysłużyć się: _: perf: subj{np(str)} + {np(inst)} + {cp(że)}
przysłużyć się: _: perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przystawiać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
przystawić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przystawić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
przystąpić: _: perf: subj{np(str)} + {prepnp(do,gen)}
przystępować: _: imperf: subj{np(str)} + {prepnp(do,gen)}
przystosować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przystosować się: _: perf: 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)}
przystosowywać się: _: imperf: subj{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}
przyswajać: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przyswajać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyswajać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przyswoić: _: perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyswoić: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyswoić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przyświecać: _: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
przyświecać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przytakiwać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
przytakiwać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
przytaknąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
przytaknąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
przytknąć: _: 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)}
przytknąć się: _: perf: subj{np(str)} + {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)}
przytrafiać się: _: imperf: subj,controllee{infp(_)} + controller{np(dat)}
przytrafiać się: _: imperf: subj{cp(że)} + {np(dat)}
przytrafiać się: _: imperf: subj{np(str)} + {np(dat)}
przytrafić się: _: perf: subj,controllee{infp(_)} + controller{np(dat)}
przytrafić się: _: perf: subj{cp(że)} + {np(dat)}
przytrafić się: _: perf: subj{np(str)} + {np(dat)}
przytrzymać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {xp(locat)}
przytrzymać się: _: perf: subj{np(str)} + {np(gen)}
przytrzymywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {xp(locat)}
przytrzymywać się: _: imperf: subj{np(str)} + {np(gen)}
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}
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)}
przytykać się: _: imperf: subj{np(str)} + {np(dat)}
przytykać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
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ązać się: _: perf: 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)}
przywiązywać się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywieść: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywieść: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywieść: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że)}
przywieść: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywitać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przywitać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przywitać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
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)}
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ć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyznać: _: perf: subj{np(str)} + {or}
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}
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}
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}
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)}
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)}
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)}
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)}
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)}
psuć się: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
psuć się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
psyknąć: _: perf: subj{np(str)} + {xp(locat)}
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)}
pukać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pukać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
pulsować: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pustoszeć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
pustoszyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
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)}
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)}
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ć: _: 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)}
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)}
rabować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
rabować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
rachować się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
raczyć: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
raczyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
raczyć się: _: imperf: subj{np(str)} + {np(inst)}
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)}
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)}
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)}
rajcować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {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ć się: _: _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ranić się: _: _: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
ratować: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
ratować: _: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
ratować: _: imperf: subj{np(str)} + 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)}
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(w,loc)}
ratować się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
ratyfikować: _: _: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
razić: _: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
razić: _: _: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
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)}
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ć: _: _: subj{np(str)} + obj{np(str)} + {np(inst)}
reaktywować się: _: _: subj{np(str)}
realizować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
realizować się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
realizować się: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
reanimować: _: _: subj{np(str)} + obj{np(str)} + {np(inst)}
reanimować się: _: _: subj{np(str)} + {np(inst)}
recytować: _: imperf: subj{np(str)} + obj{np(str)}
recytować: _: imperf: subj{np(str)} + {or}
reformować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
reformować 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)}
regulować się: _: imperf: subj{np(str)}
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)} + {np(dat)} + {cp(żeby)}
rekomendować: _: imperf: subj{np(str)} + {np(dat)} + {infp(_)}
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}
rekonstruować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rekonstruować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
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)}
rekwirować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
remontować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
remontować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
repetować: _: imperf: subj{np(str)} + obj{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}
replikować się: _: imperf: subj{np(str)}
represjonować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
reprezentować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
respektować: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
rezygnować: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
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)}
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)}
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)}
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)}
rodzić się: _: imperf: subj,controller{np(str)} + controllee{adjp(inst)}
rodzić się: _: imperf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
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)}
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)}
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)}
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)}
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)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozbijać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozbijać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbijać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
rozbijać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
rozbijać się: _: perf: subj{np(str)} + {np(inst)}
rozbijać się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozbijać się: _: perf: subj{np(str)} + {xp(locat)}
rozboleć: _: perf: subj{np(str)} + {np(str)} + {prepnp(od,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)}
rozchichotać się: _: perf: subj{np(str)}
rozchodzić: _: perf: subj{np(str)} + obj{np(str)}
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ć się: _: perf: subj{np(str)} + {np(dat)}
rozciąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozciąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
rozciąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozciąć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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ą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ą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)}
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)}
rozcieńczać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozcieńczać się: _: imperf: subj{np(str)}
rozcieńczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozcieńczyć się: _: perf: subj{np(str)}
rozcinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozcinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
rozcinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozcinać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
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)}
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)}
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)}
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)}
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)}
rozdmuchać się: _: perf: subj{E}
rozdmuchać się: _: perf: 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)}
rozdmuchiwać się: _: imperf: subj{E}
rozdmuchiwać się: _: imperf: subj{np(str)} + {np(dat)}
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)}
rozdzielić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozdzielić: _: perf: subj{np(str)} + obj{np(str)} + {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)}
rozdzielić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
rozdzielić się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
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}
rozdziewiczyć: _: perf: subj{np(str)} + obj{np(str)}
rozebrać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozebrać: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)}
rozebrać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozebrać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozebrać: _: perf: subj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)} + {refl}
rozebrać: _: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozedrzeć: _: 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)}
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}
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)}
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)}
rozglądać się: _: imperf: subj{np(str)} + {cp(int)} + {xp(adl)}
rozglądać się: _: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozglądać się: _: imperf: subj{np(str)} + {prepnp(po,loc); xp(locat)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
rozglądać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
rozgniewać: _: 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)}
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,że)}
rozgniewać się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
rozgoryczyć: _: perf: subj{np(str)} + {np(str)}
rozgoryczyć się: _: perf: subj{np(str)} + {comprepnp(z powodu)}
rozgromić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozgromić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
rozgrzać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rozgrzać się: _: perf: subj{np(str)} + {np(inst)}
rozjaśniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjaśniać się: _: imperf: {np(dat)} + {xp(locat)}
rozjaśniać się: _: imperf: subj{np(str)} + {np(dat)}
rozjaśnić: _: perf: 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)}
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}
rozkoszować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozkręcać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozkręcać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozkręcić: _: perf: 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)}
rozkwitać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozkwitnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozlać: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl); xp(locat)}
rozlać się: _: perf: subj{np(str)} + {prepnp(w,acc)}
rozlać się: _: perf: subj{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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozleniwiać się: _: imperf: subj{np(str)} + {np(inst)}
rozleniwić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozleniwić się: _: perf: subj{np(str)} + {np(inst)}
rozlewać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl); xp(locat)}
rozlewać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
rozlewać się: _: imperf: subj{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)}
rozluźnić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozluźnić 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ładować się: _: perf: 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ładowywać się: _: imperf: subj{np(str)} + {np(dat)}
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ć: _: 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łączać się: _: imperf: subj{np(str)} + {np(dat)}
rozłączać się: _: imperf: 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łączyć się: _: perf: subj{np(str)} + {np(dat)}
rozłączyć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
rozmarzać: _: imperf: subj{np(str)} + {np(str)}
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)}
rozmarzyć: _: perf: 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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozmazać się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozmazywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozmazywać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozmierzwić się: _: perf: subj{np(str)} + {np(dat)}
rozmieszczać: _: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozmieszczać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
rozmieścić: _: perf: 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)}
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ękczać się: _: imperf: subj{np(str)} + {np(dat)}
rozmiękczać się: _: imperf: 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ękczyć się: _: perf: subj{np(str)} + {np(dat)}
rozmiękczyć się: _: perf: subj{np(str)} + {xp(locat)}
rozmijać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
rozminąć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozmrażać się: _: imperf: subj{np(str)} + {np(dat)}
rozmrozić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozmrozić się: _: perf: subj{np(str)} + {np(dat)}
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ślać się: _: imperf: subj{np(str)}
rozmyślać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
rozmyślić się: _: perf: subj{np(str)}
rozmyślić się: _: perf: subj{np(str)} + {prepnp(z,gen)}
rozochocić: _: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
rozochocić się: _: perf: subj{np(str)} + {np(inst)}
rozochocić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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ę: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpadać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpadać się: _: perf: subj{E}
rozpadać się: _: perf: subj{np(str)}
rozpakować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpakować się: _: perf: subj{np(str)}
rozpakowywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpakowywać się: _: imperf: subj{np(str)}
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)}
rozpaść się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpaść się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpędzić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpędzić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozpić: _: perf: subj{np(str)} + obj{np(str)}
rozpić się: _: perf: subj{np(str)}
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ć: _: imperf: subj{np(str)} + obj{np(str)}
rozpijać się: _: imperf: subj{np(str)}
rozplanować: _: perf: subj{np(str)} + obj{cp(int)}
rozplanować: _: perf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozplanowywać: _: imperf: subj{np(str)} + obj{cp(int)}
rozplanowywać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozplątać: _: 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ątać się: _: perf: 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}
rozplątywać się: _: imperf: subj{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ł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ąć: _: 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)} + {or}
rozpocząć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
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)}
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)} + {or}
rozpoczynać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rozpoczynać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
rozpoczynać się: _: imperf: subj{np(str)} + {np(inst)}
rozpoczynać się: _: imperf: subj{np(str)} + {or}
rozpoczynać się: _: imperf: subj{np(str)} + {prepnp(od,gen)}
rozpoczynać się: _: imperf: subj{np(str)} + {xp(locat)}
rozpoczynać się: _: imperf: subj{np(str)} + {xp(temp)}
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ądzać się: _: imperf: 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)}
rozporządzić się: _: perf: subj{np(str)} + {np(inst)}
rozpowszechniać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpowszechniać się: _: imperf: subj{np(str)} + {xp(locat)}
rozpowszechnić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpowszechnić się: _: perf: subj{np(str)} + {xp(locat)}
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)} + {cp(int); ncp(str,int)}
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)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozpoznać: _: perf: subj{np(str)} + {or}
rozpoznać: _: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozpoznać: _: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
rozpoznać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
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)}
rozpruć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozpruć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpruwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozpruwać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
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)}
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)}
rozpuszczać się: _: imperf: 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)}
rozpuścić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozrastać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozrastać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozrastać się: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozrastać się: _: imperf: subj{np(str)} + {xp(adl)}
rozrosnąć się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozrosnąć się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozrosnąć się: _: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozrosnąć się: _: perf: subj{np(str)} + {xp(adl)}
rozróżniać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozróżniać: _: imperf: subj{np(str)} + {prepnp(między,inst)}
rozróżniać: _: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozróżniać: _: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozróżniać: _: imperf: subj{np(str)} + {prepnp(pomiędzy,inst)}
rozróżnić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozróżnić: _: perf: subj{np(str)} + {prepnp(między,inst)}
rozróżnić: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozróżnić: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozróżnić: _: perf: subj{np(str)} + {prepnp(pomiędzy,inst)}
rozruszać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozruszać się: _: perf: subj{np(str)} + {np(dat)}
rozsądzać: _: imperf: subj{np(str)} + {cp(int)}
rozsądzać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozsądzić: _: perf: subj{np(str)} + {cp(int)}
rozsądzić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int)}
rozstać się: _: perf: subj{np(str)} + {prepnp(z,inst)}
rozstawać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
rozstawiać: _: 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)}
rozstawiać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozstawiać się: _: imperf: 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)}
rozstawić się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozstawić się: _: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozstrzelać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
rozstrzelać się: _: perf: subj{np(str)}
rozstrzeliwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
rozśmieszać: _: imperf: subj{cp(gdy)} + {np(str)}
rozśmieszać: _: imperf: subj{cp(int)} + {np(str)}
rozśmieszać: _: imperf: subj{cp(jak)} + {np(str)}
rozśmieszać: _: imperf: subj{cp(jeśli)} + {np(str)}
rozśmieszać: _: imperf: subj{cp(kiedy)} + {np(str)}
rozśmieszać: _: imperf: subj{cp(że)} + {np(str)}
rozśmieszać: _: imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozśmieszać: _: imperf: subj{np(str)} + {np(str)} + {cp(że)}
rozśmieszać: _: imperf: subj{np(str)} + {np(str)} + {or}
rozśmieszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
rozśmieszyć: _: perf: subj{cp(gdy)} + {np(str)}
rozśmieszyć: _: perf: subj{cp(int)} + {np(str)}
rozśmieszyć: _: perf: subj{cp(jak)} + {np(str)}
rozśmieszyć: _: perf: subj{cp(jeśli)} + {np(str)}
rozśmieszyć: _: perf: subj{cp(kiedy)} + {np(str)}
rozśmieszyć: _: perf: subj{cp(że)} + {np(str)}
rozśmieszyć: _: perf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
rozśmieszyć: _: perf: subj{np(str)} + {np(str)} + {cp(że)}
rozśmieszyć: _: perf: subj{np(str)} + {np(str)} + {or}
rozśmieszyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
rozświetlać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozświetlać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
rozświetlić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozświetlić się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
roztrwonić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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}
rozumieć się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
rozumieć się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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}
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)}
rozweselać się: _: imperf: 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)}
rozweselić się: _: perf: subj{np(str)} + {np(inst)}
rozwiać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwiać się: _: perf: subj{np(str)} + {np(dat)}
rozwiać się: _: perf: subj{np(str)} + {xp(adl)}
rozwiać się: _: perf: subj{np(str)} + {xp(locat)}
rozwieść: _: perf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
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)} + 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ć: _: 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)}
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)}
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)}
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)}
rozwodzić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
rozwozić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozwozić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rozwozić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozwydrzyć: _: perf: subj{np(str)} + obj{np(str)}
rozwydrzyć się: _: perf: subj{np(str)} + {np(dat)}
rozwydrzyć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
równać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,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óż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)}
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)}
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)}
rujnować się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
rumienić: _: imperf: subj{np(str)} + obj{np(str)}
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,że)}
rumienić się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
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)}
ruszać się: _: imperf: subj{np(str)} + {np(dat)}
ruszać się: _: imperf: 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)}
ruszyć się: _: perf: subj{np(str)} + {np(dat)}
ruszyć się: _: perf: subj{np(str)} + {xp(abl)}
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)}
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)}
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)}
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)}
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)}
rysować się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
rysować się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
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ć: _: imperf: subj{np(str)} + obj{np(inst)}
rządzić: _: imperf: subj{np(str)} + {xp(locat)}
rządzić się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
rządzić się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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}
rzeźbić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
rzępolić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rzucać: _: 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}
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)} + {prepnp(o,acc); prepncp(o,acc,że)}
rzucać się: _: imperf: 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}
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)} + {prepnp(o,acc); prepncp(o,acc,że)}
rzucić się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
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)}
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)} + obj{np(str)} + {xp(adl)}
rżnąć: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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ąć: _: _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
rżnąć: _: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rżnąć się: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
satysfakcjonować: _: imperf: subj{cp(że)} + {np(str)}
satysfakcjonować: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
sądzić: _: imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
sądzić: _: imperf: subj{np(str)} + {cp(że)}
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,że)}
sądzić: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
sądzić: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
sądzić się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(z,inst)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
scalać się: _: imperf: 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)}
scalić się: _: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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)}
schodzić: _: perf: subj{np(str)} + obj{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ć się: _: perf: subj{np(str)}
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}
schować się: _: perf: subj{np(str)} + {prepnp(przy,loc)}
schować się: _: perf: subj{np(str)} + {prepnp(z,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)}
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ć: _: imperf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
schylać się: _: imperf: subj{np(str)} + {prepnp(po,acc)}
schylać się: _: imperf: subj{np(str)} + {prepnp(przed,inst)}
schylić: _: perf: 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)}
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)}
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)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
sforsować: _: perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
sforsować się: _: perf: subj{np(str)} + {np(inst)}
siać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
siać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
siadać: _: imperf: subj{np(str)} + {prepnp(do,gen)}
siadać: _: imperf: subj{np(str)} + {xp(adl)}
siadać: _: imperf: subj{np(str)} + {xp(locat)}
siąść: _: perf: subj{np(str)} + {prepnp(do,gen)}
siąść: _: perf: subj{np(str)} + {xp(adl)}
siąść: _: perf: subj{np(str)} + {xp(locat)}
siedzieć: _: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
siedzieć: _: imperf: subj{np(str)} + {lexnp(inst,sg,'kamień',natr)}
siedzieć: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'kark',natr)}
siedzieć: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
siedzieć: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
siedzieć: _: imperf: subj{np(str)} + {prepnp(nad,inst)}
siedzieć: _: imperf: subj{np(str)} + {prepnp(na,loc)}
siedzieć: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
siedzieć: _: imperf: subj{np(str)} + {prepnp(w,loc)}
siedzieć: _: imperf: subj{np(str)} + {prepnp(za,acc)} + {xp(dur)}
silić się: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
silić się: _: imperf: subj{np(str)} + {cp(żeby)}
silić się: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
siłować się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
siodłać: _: imperf: subj{np(str)} + obj{np(str)}
siorbać: _: imperf: subj{np(str)} + {np(inst)}
siorbać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
siorbnąć: _: perf: subj{np(str)} + {np(inst)}
siorbnąć: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
siwieć: _: imperf: subj{np(str)} + {np(dat)}
siwieć: _: imperf: subj{np(str)} + {xp(locat)}
siwieć: _: imperf: {xp(locat)}
skakać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skakać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
skakać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
skakać: _: imperf: subj{np(str)} + obj{np(str)}
skakać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
skakać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
skakać: _: imperf: subj{np(str)} + {prepnp(koło,gen)}
skakać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
skakać: _: imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
skakać: _: imperf: subj{np(str)} + {prepnp(przed,inst)}
skakać: _: imperf: subj{np(str)} + {prepnp(wokół,gen)}
skakać: _: imperf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,acc,sg,'ogień',natr)}
skakać: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
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}
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)}
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,ż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)}
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}
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)}
skasować się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
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)}
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)}
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)}
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)}
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ć: _: 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(ku,dat)}
skierować: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
skierować się: _: perf: subj{np(str)} + {prepnp(ku,dat)}
skierować się: _: perf: subj{np(str)} + {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)}
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ł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ładować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skoczyć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skoczyć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
skoczyć: _: perf: subj{np(str)} + obj{np(str)}
skoczyć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
skoczyć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
skoczyć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
skoczyć: _: perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
skoczyć: _: perf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,acc,sg,'ogień',natr)}
skoczyć: _: perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
skojarzyć: _: 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)}
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)}
skołować: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
skołować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
skołować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
skołować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
skomentować: _: perf: subj{np(str)} + {cp(że)}
skomentować: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {or}
skomleć: _: imperf: subj{np(str)} + {cp(że)}
skomleć: _: imperf: subj{np(str)} + {cp(żeby)}
skomleć: _: imperf: subj{np(str)} + {or}
skomleć: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
skomleć: _: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
skomplikować: _: 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)}
skomplikować się: _: perf: subj{np(str)} + {np(dat)}
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ć: _: 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)}
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)}
skonstruować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skontaktować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skontaktować się: _: perf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
skontrolować: _: perf: subj{np(str)} + {cp(int)} + {refl}
skontrolować: _: perf: subj{np(str)} + {cp(że)}
skontrolować: _: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
skontrolować: _: perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
skończyć: _: 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)}
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)}
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)}
skopać się: _: perf: subj{np(str)} + {np(dat)}
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)}
skracać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
skracać się: _: imperf: subj{np(str)} + {prepnp(o,acc)}
skraplać: _: imperf: subj{np(str)} + {np(dat)} + {np(str)}
skraplać: _: imperf: subj{np(str)} + obj{np(str)}
skraplać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
skraplać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
skraść: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
skraść: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
skreślić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
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ę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ę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ę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)}
skroplić: _: perf: subj{np(str)} + {np(dat)} + {np(str)}
skroplić: _: perf: subj{np(str)} + obj{np(str)}
skroplić się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
skroplić się: _: perf: subj{np(str)} + {prepnp(w,acc)}
skrócić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
skrócić się: _: perf: subj{np(str)} + {prepnp(o,acc)}
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)}
skrzeczeć: _: imperf: subj{np(str)} + {comprepnp(na temat)}
skrzeczeć: _: imperf: subj{np(str)} + {cp(że)}
skrzeczeć: _: imperf: subj{np(str)} + {np(inst)}
skrzeczeć: _: imperf: subj{np(str)} + {np(str)} + {prepadjp(po,postp)}
skrzeczeć: _: imperf: subj{np(str)} + {or}
skrzeczeć: _: imperf: subj{np(str)} + {prepnp(do,gen)}
skrzeczeć: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
skrzyć: _: 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)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
skrzywić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
skupiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
skupiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
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)}
skupić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
skupić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
skupić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
skupić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
skupować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
skupować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skurczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
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)}
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)}
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ł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łuchać się: _: imperf: subj{np(str)} + {np(gen)}
służyć: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
służyć: _: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {np(dat)}
służyć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
służyć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(dla,gen)}
służyć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
służyć: _: imperf: subj{np(str)} + {prepnp(pod,inst)}
służyć: _: imperf: subj{np(str)} + {prepnp(u,gen)}
służyć: _: imperf: subj{np(str)} + {prepnp(w,loc)}
słychać: _: imperf: {cp(int)} + {xp(locat)}
słychać: _: imperf: {cp(jak)} + {xp(locat)}
słychać: _: imperf: {cp(że); cp(żeby2)} + {xp(locat)}
słychać: _: imperf: {ncp(str,int)} + {xp(locat)}
słychać: _: imperf: {ncp(str,jak)} + {xp(locat)}
słychać: _: imperf: {np(str); ncp(str,że); or} + {xp(locat)}
słychać: _: imperf: {prepncp(o,loc,int); prepncp(o,loc,jak)} + {xp(locat)}
słychać: _: imperf: {prepncp(o,loc,że)} + {xp(locat)}
słychać: _: imperf: {prepnp(o,loc)} + {xp(locat)}
słynąć: _: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
słynąć: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
słynąć: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
słynąć: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
słyszeć: _: imperf: subj{np(str)} + obj{cp(jakoby)}
słyszeć: _: imperf: subj{np(str)} + obj{cp(jak)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: _: imperf: subj{np(str)} + obj{cp(żeby2)}
słyszeć: _: imperf: subj{np(str)} + obj{cp(że)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: _: imperf: subj{np(str)} + obj{np(str); cp(int); cp(jak); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(inst)}
słyszeć: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: _: imperf: subj{np(str)} + obj{np(str); prepnp(o,loc); cp(int); cp(jak); cp(że); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(od,gen)}
słyszeć: _: imperf: subj{np(str)} + {prepncp(o,loc,jakoby)}
słyszeć: _: imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
słyszeć: _: imperf: subj{np(str)} + {prepnp(od,gen)} + {or}
słyszeć: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby2)} + {nonch}
słyszeć: _: imperf: subj{np(str)} + {refl}
smakować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
smakować: _: imperf: subj{np(str)} + {np(dat)}
smakować: _: imperf: subj{np(str)} + obj{np(str)}
smarować: _: imperf: subj{np(str)} + {np(inst)} + {refl}
smarować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
smarować: _: imperf: subj{np(str)} + {xp(adl)}
smażyć: _: 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)}
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)}
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)}
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}
snuć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
solić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
solić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
solidaryzować się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
spacerować: _: imperf: subj{np(str)} + {xp(perl)}
spać: _: imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
spać: _: imperf: subj{np(str)} + {prepnp(nad,inst)}
spać: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(u,gen)}
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)}
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)}
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)}
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)}
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)}
sparaliżować: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)}
sparaliżować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sparaliżować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)}
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)}
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)}
spaść się: _: perf: subj{np(str)} + {np(inst)}
spaść się: _: perf: subj{np(str)} + {prepnp(na,loc)}
specjalizować się: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
spekulować: _: imperf: subj{np(str)} + {comprepnp(na temat)}
spekulować: _: imperf: subj{np(str)} + {cp(int)}
spekulować: _: imperf: subj{np(str)} + {cp(że)}
spekulować: _: imperf: subj{np(str)} + {np(inst)}
spekulować: _: imperf: subj{np(str)} + {or}
spekulować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
spekulować: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
spełniać: _: imperf: subj{np(str)} + obj{np(str)}
spełniać się: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,nom)}
spełniać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
spełnić: _: perf: 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)}
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)}
spędzić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
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{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)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spić się: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
spić się: _: perf: subj{np(str)} + {np(inst)}
spierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
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)}
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)}
spieszyć: _: perf: subj{np(str)} + obj{np(str)}
spieszyć: _: perf: subj{np(str)} + {refl}
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)}
spijać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spijać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
spijać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
spijać się: _: imperf: subj{np(str)} + {np(inst)}
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)}
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)}
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)}
spisać się: _: perf: 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)}
spisywać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
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)}
splamić się: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
splatać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
splatać się: _: imperf: 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ść się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
spleść się: _: perf: subj{np(str)} + {np(inst)}
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łonąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
spocić się: _: perf: subj{np(str)} + {np(dat)}
spocząć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
spocząć: _: perf: subj{np(str)} + {prepnp(na,loc)}
spocząć: _: perf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
spocząć: _: perf: subj{np(str)} + {xp(dur)}
spoczywać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
spoczywać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
spoczywać: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
spodobać się: _: perf: {np(dat)} + {xp(locat)}
spodobać się: _: perf: subj,controllee{infp(_)} + controller{np(dat)}
spodobać się: _: perf: subj{cp(gdy)} + {np(dat)}
spodobać się: _: perf: subj{cp(jak)} + {np(dat)}
spodobać się: _: perf: subj{cp(kiedy)} + {np(dat)}
spodobać się: _: perf: subj{cp(że)} + {np(dat)}
spodobać się: _: perf: subj{np(str); ncp(str,jak); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
spodziewać się: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
spodziewać się: _: imperf: subj{np(str)} + {np(gen); cp(że); cp(żeby); ncp(gen,że); ncp(gen,żeby)} + {prepnp(po,loc)}
spodziewać się: _: imperf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)}
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ą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ądnąć: _: 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)}
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)}
sponiewierać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
sponiewierać się: _: perf: subj{np(str)}
sporządzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
sporządzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
sposobić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
sposobić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
sposobić się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
sposobić się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
sposób: neg: imperf: {cp(żeby)}
sposób: neg: imperf: {infp(_)}
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,że)}
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)}
spotkać: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
spotkać: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spotkać się: _: perf: subj{np(str)} + {prepnp(z,inst)}
spotykać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
spotykać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spotykać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
spoważnieć: _: perf: subj{np(str)} + {np(dat)}
spowiadać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
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)}
spowodować: _: perf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)} + {np(inst); ncp(inst,że)} + {xp(locat)}
spóźniać się: _: imperf: subj{np(str)} + {np(acc)} + {prepnp(do,gen); prepnp(na,acc)}
spóźniać się: _: imperf: subj{np(str)} + {np(acc)} + {prepnp(z,inst)}
spóźniać się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(o,acc)}
spóźniać się: _: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
spóźnić się: _: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepnp(na,acc)}
spóźnić się: _: perf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
spóźnić się: _: perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(o,acc)}
spóźnić się: _: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
sprawdzać: _: 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)}
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)}
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)}
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)}
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)}
sprawiać się: _: imperf: 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)}
sprawić się: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
sprawować: _: imperf: subj{np(str)} + obj{np(str)}
sprawować się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
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}
sprecyzować się: _: perf: subj{np(str)}
sprezentować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sprężać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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ężyć: _: perf: 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)}
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)}
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)}
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(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)}
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(adl)}
sprowokować: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {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)}
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óbować się: _: perf: subj{np(str)} + {prepnp(z,inst)}
sprywatyzować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sprywatyzować się: _: perf: subj{np(str)}
sprzątać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
sprzątać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sprzątać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
sprzeciwiać się: _: imperf: subj{np(str)} + {cp(że)}
sprzeciwiać się: _: imperf: subj{np(str)} + {cp(żeby)}
sprzeciwiać się: _: imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)} + {or}
sprzeciwiać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprzeciwić się: _: perf: subj{np(str)} + {cp(że)}
sprzeciwić się: _: perf: subj{np(str)} + {cp(żeby)}
sprzeciwić się: _: perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)} + {or}
sprzeciwić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
sprzeczać się: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
sprzeniewierzać: _: imperf: subj{np(str)} + obj{np(str)}
sprzeniewierzać się: _: imperf: subj{np(str)} + {np(dat)}
sprzeniewierzyć: _: perf: subj{np(str)} + obj{np(str)}
sprzeniewierzyć się: _: perf: subj{np(str)} + {np(dat)}
sprzyjać: _: imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
sprzyjać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
spustoszyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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)}
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)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
stacjonować: _: imperf: subj{np(str)} + {xp(locat)}
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)}
staczać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
starać się: _: imperf: subj,controller{np(str)} + controllee{prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby); infp(_)}
starczyć: _: perf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
starczyć: _: perf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
starczyć: _: perf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
starczyć: _: perf: {np(gen)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
starczyć: _: perf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: _: perf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: _: perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: _: perf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
starczyć: _: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
starczyć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)}
starczyć: _: perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
starczyć: _: perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
startować: _: imperf: subj{np(str)} + {prepnp(do,gen)}
startować: _: imperf: subj{np(str)} + {prepnp(w,loc)}
startować: _: imperf: subj{np(str)} + {xp(abl)}
statystować: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
statystować: _: imperf: subj{np(str)} + {xp(locat)}
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)}
stawiać: _: imperf: subj{np(str)} + {prepnp(za,acc)} + {infp(_)} + {lexnp(dat,_,'siebie',natr)}
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)}
stemplować: _: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
stemplować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sterczeć: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
sterczeć: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
sterować: _: imperf: subj{np(str)} + obj{np(inst)} + {np(inst)}
sterować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
sterroryzować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
stękać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
stękać: _: imperf: subj{np(str)} + {np(dat)} + {or}
stękać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
stękać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
stękać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
stękać: _: imperf: subj{np(str)} + {prepnp(pod,inst)}
stękać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
stęknąć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
stęknąć: _: perf: subj{np(str)} + {np(dat)} + {or}
stęknąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
stęknąć: _: perf: subj{np(str)} + {prepnp(pod,inst)}
stęknąć: _: perf: subj{np(str)} + {prepnp(z,gen)}
stłuc: _: 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łuc się: _: perf: subj{np(str)} + {np(inst)}
stłuc się: _: perf: subj{np(str)} + {prepnp(o,acc)}
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)}
stoczyć się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
stosować się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
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)} + {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)}
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)}
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)}
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)}
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)}
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)}
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)}
stronić: _: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
stroszyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
stroszyć się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
stroszyć się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
struć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
struć się: _: perf: subj{np(str)} + {np(inst)}
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)}
strzaskać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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)}
strzec się: _: imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
strzec się: _: imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
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)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
strzyc się: _: imperf: subj{np(str)} + {xp(locat)} + {advp(misc)}
studiować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
studiować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
studiować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
stwarzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stwarzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
stwarzać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stwierdzać: _: imperf: subj{np(str)} + {cp(int)}
stwierdzać: _: imperf: subj{np(str)} + {cp(że)}
stwierdzać: _: imperf: subj{np(str)} + obj{np(str)}
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)}
stwierdzić: _: perf: subj{np(str)} + {or}
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)}
stworzyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
stymulować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
sugerować się: _: imperf: subj{np(str)} + {cp(że)}
sugerować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
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)}
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)}
suszyć się: _: imperf: subj{np(str)} + {xp(locat)}
swatać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
swatać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
swędzić: _: imperf: {np(str)} + {xp(locat)}
swędzić: _: imperf: subj{cp(żeby)} + {np(str)}
swędzić: _: imperf: subj{lexnp(str,sg,'ręka',natr)} + {np(str)} + {prepnp(na,acc)}
swędzić: _: imperf: subj{np(str)} + {np(str)}
swędzić: _: imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
swędzieć: _: imperf: {np(str)} + {xp(locat)}
swędzieć: _: imperf: subj{cp(żeby)} + {np(str)}
swędzieć: _: imperf: subj{lexnp(str,sg,'ręka',natr)} + {np(str)} + {prepnp(na,acc)}
swędzieć: _: imperf: subj{np(str)} + {np(str)}
swędzieć: _: imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
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)}
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)}
sympatyzować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sympatyzować: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
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)}
sypać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
sypać się: _: imperf: 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)}
sypnąć się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
sypnąć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
systematyzować: _: imperf: subj{np(str)} + {np(inst)} + {refl}
systematyzować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sytuować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
sytuować się: _: imperf: subj{np(str)} + {xp(locat)} + {advp(misc)}
szacować: _: imperf: subj{np(str)} + {cp(że)}
szacować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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ć: _: imperf: subj{np(str)} + obj{np(inst)}
szamotać: _: imperf: subj{np(str)} + obj{np(str)}
szamotać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
szanować się: _: imperf: subj{np(str)}
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)}
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)}
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)}
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)}
szarpnąć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
szarpnąć się: _: perf: subj{np(str)} + {xp(adl)}
szczekać: _: imperf: subj{np(str)} + {np(str)}
szczekać: _: imperf: subj{np(str)} + {or}
szczekać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
szczekać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
szczekać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
szczekać: _: imperf: subj{np(str)} + {prepnp(o,loc)}
szczekać: _: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
szczepić: _: 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)}
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)}
szczerzyć: _: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
szczerzyć: _: imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
szczerzyć się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
szczerzyć się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
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ędzić: _: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
szczędzić się: neg: imperf: subj{np(str)} + {prepnp(w,loc)}
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}
szefować: _: imperf: subj{np(str)} + {np(dat)}
szefować: _: imperf: subj{np(str)} + {xp(locat)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(int)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {or}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
szepnąć: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',natr)} + {or}
szepnąć: _: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
szepnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
szepnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
szepnąć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
szepnąć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szepnąć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szepnąć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
szeptać: _: imperf: subj{np(str)} + {cp(int)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: imperf: subj{np(str)} + {cp(że)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szeptać: _: imperf: subj{np(str)} + {prepadjp(po,postp)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: imperf: subj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)} + {or}
szeptać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
szeptać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szeptać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szeptać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
szeptać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
szeptać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
szeptać: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
szeptać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
szermować: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
szermować: _: imperf: subj{np(str)} + {prepnp(o,loc)}
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)}
szklić się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
szklić się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
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ć: 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}
szkodzić: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat); ncp(dat,żeby)} + {prepnp(na,acc)}
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)}
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)}
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)}
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)}
szyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
szyć: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
szyć: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
szyć: _: imperf: subj{np(str)} + {xp(perl)}
szydzić: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
szydzić: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
szydzić: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
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}
szykować się: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
szykować się: _: imperf: subj{np(str)} + {xp(locat)}
ś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ąć: _: 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)}
ściągnąć się: _: perf: subj{np(str)} + {np(dat)}
ś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ć: _: 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)}
ścielić się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
ścielić się: _: imperf: subj{np(str)} + {np(inst)} + {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)}
ściemniać się: _: imperf: subj{np(str)} + {np(dat)}
ściemniać się: _: imperf: {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)}
ściemnić się: _: perf: subj{np(str)} + {np(dat)}
ściemnić się: _: perf: {xp(locat)}
ścienić: _: perf: subj{np(str)}
ścigać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
ścigać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
ścigać się: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int)} + {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)}
ściskać się: _: imperf: subj{np(str)} + {np(dat)}
ściskać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
ś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)}
ścisnąć się: _: perf: subj{np(str)} + {np(dat)}
śledzić: _: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)} + {np(inst)}
ślepnąć: _: imperf: subj{np(str)} + {prepnp(od,gen)}
ślepnąć: _: imperf: subj{np(str)} + {prepnp(wskutek,gen)}
ślepnąć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
ślęczeć: _: imperf: subj{np(str)} + {prepnp(nad,inst)}
ślęczeć: _: imperf: subj{np(str)} + {xp(locat)}
ślinić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ś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)}
ś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{np(str)} + obj{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)} + {prepnp(na,acc)}
śmiać się: _: imperf: subj{lexnp(str,_,'oko',natr)} + {np(dat)} + {prepnp(do,gen)}
śmiać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
śmiać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
śmiać się: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
śmiać się: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
śmieć: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
śmierdzieć: _: imperf: controller{np(dat)} + controllee{xp(mod)} + {xp(abl)}
śmierdzieć: _: imperf: controller{prepnp(od,gen)} + controllee{xp(mod)}
śmierdzieć: _: imperf: controller{xp(locat)} + controllee{xp(mod)}
śmierdzieć: _: imperf: {np(dat)} + {np(inst)} + {xp(abl)}
śmierdzieć: _: imperf: {np(inst)} + {prepnp(od,gen)}
śmierdzieć: _: imperf: {np(inst)} + {xp(locat)}
śmierdzieć: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
śmierdzieć: _: imperf: subj{np(str)} + {np(inst)}
śmieszyć: _: imperf: subj{cp(gdy)} + {np(str)}
śmieszyć: _: imperf: subj{cp(int)} + {np(str)}
śmieszyć: _: imperf: subj{cp(jak)} + {np(str)}
śmieszyć: _: imperf: subj{cp(jeśli)} + {np(str)}
śmieszyć: _: imperf: subj{cp(kiedy)} + {np(str)}
śmieszyć: _: imperf: subj{cp(że)} + {np(str)}
śmieszyć: _: imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
śmigać: _: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
śmigać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
śmigać: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śmigać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
śmigać: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śmignąć: _: perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
śmignąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
śmignąć: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śmignąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
śmignąć: _: perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
śnić: _: 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)}
ś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)}
ś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)}
ś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)}
śpiewać: _: imperf: subj{np(str)} + {cp(że)}
śpiewać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
śpiewać: _: imperf: subj{np(str)} + {np(inst)} + {or}
śpiewać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
świadczyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
świadczyć: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'rzecz',ratr)}
świadczyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
świadczyć: _: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
świadczyć: _: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'niekorzyść',ratr)}
świadczyć: _: imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)} + {advp(misc)}
świadczyć: _: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(przed,inst)}
świadczyć: _: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)} + {prepnp(przed,inst)} + {cp(że)}
ś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)}
świecić się: _: imperf: subj{lexnp(str,pl,'oko',atr)} + {np(dat)} + {prepnp(do,gen)}
świecić się: _: imperf: subj{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)}
świtać: _: perf: {np(dat)} + {advp(misc)}
świtać: _: perf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
świtać: _: perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
świtać: _: perf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
świtać: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
taczać się: _: imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
taczać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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)}
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)}
taranować: _: imperf: subj{np(str)} + obj{np(str)}
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)}
targać się: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
targać się: _: imperf: 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)}
targnąć się: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
targnąć się: _: perf: subj{np(str)} + {xp(adl)}
tarzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tarzać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
tarzać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
tarzać się: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
telefonować: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
telefonować: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
telefonować: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
telefonować: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
telefonować: _: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
teoretyzować: _: imperf: subj{np(str)} + {comprepnp(na temat)}
teoretyzować: _: imperf: subj{np(str)} + {comprepnp(w kwestii)}
teoretyzować: _: imperf: subj{np(str)} + {comprepnp(w sprawie)}
teoretyzować: _: imperf: subj{np(str)} + {cp(int)}
teoretyzować: _: imperf: subj{np(str)} + {cp(że)}
teoretyzować: _: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
terroryzować: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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ępić się: _: imperf: subj{np(str)} + {np(dat)}
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ęsknić się: _: imperf: {np(dat)} + {prepnp(do,gen)}
tęsknić się: _: imperf: {np(dat)} + {prepnp(za,inst)}
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)}
tkwić: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
tkwić: _: imperf: subj{np(str)} + {xp(locat)}
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ł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ł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ł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ł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ć: _: 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)}
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)}
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)}
topić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
topić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
topić się: _: imperf: subj{np(str)} + {np(dat)}
torować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
torować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
towarzyszyć: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
towarzyszyć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
towarzyszyć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
towarzyszyć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
towarzyszyć: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
towarzyszyć: _: imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
tracić: _: imperf: subj{np(str)} + {lexnp(str,sg,'grunt',natr)} + {preplexnp(pod,inst,pl,'noga',natr)}
tracić: _: imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,pl,'oko',natr)}
tracić: _: imperf: subj{np(str)} + obj{np(str)} + {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ć: _: 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)}
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)}
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)}
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)}
traktować: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
traktować: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
traktować: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
traktować: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
traktować: _: imperf: subj{np(str)} + obj,controller{np(str)} + 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,że)}
trącać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trącać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
trącić: _: imperf: subj{np(str)} + {np(inst)}
trącić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
trącić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
trenować się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
triumfować: _: imperf: subj{np(str)} + {cp(że)}
triumfować: _: imperf: subj{np(str)} + {np(inst)}
triumfować: _: imperf: subj{np(str)} + {or}
triumfować: _: imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
tropić: _: 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)}
tropić się: _: imperf: subj{np(str)}
troszczyć się: _: imperf: subj{np(str)} + {cp(int)}
troszczyć się: _: imperf: subj{np(str)} + {cp(że)}
troszczyć się: _: imperf: subj{np(str)} + {cp(żeby)}
troszczyć się: _: imperf: subj{np(str)} + {np(inst)}
troszczyć się: _: imperf: subj{np(str)} + {or}
troszczyć się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
truchtać: _: imperf: subj{np(str)} + {prepnp(za,inst)}
truchtać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(adl)}
truchtać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
trudnić się: _: imperf: subj{np(str)} + {np(inst)}
trudno: _: _: {np(dat)} + {infp(_)}
trwać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
trwać: _: imperf: subj{np(str)} + {prepnp(przy,loc)}
trwać: _: imperf: subj{np(str)} + {prepnp(w,loc)}
trwać: _: imperf: subj{np(str)} + {xp(dur)}
trwać: _: imperf: subj{np(str)} + {xp(locat)}
trwonić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
tryskać: _: imperf: {np(inst)} + {prepnp(od,gen)}
tryskać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
tryskać: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
tryskać: _: imperf: subj{np(str)} + {prepnp(od,gen)}
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ąść: _: imperf: {np(inst)}
trząść: _: imperf: obj{np(str)}
trząść: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
trząść: _: imperf: subj{np(str)} + obj{np(str)}
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)}
trzeba: _: imperf: {advp(pron)}
trzeba: _: imperf: controller{np(dat)} + controllee{infp(_)} + {cp(żeby)}
trzeba: _: imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
trzeba: _: imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
trzeba: _: imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
trzeba: _: imperf: {np(gen)} + {cp(że)}
trzeć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzeć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzeć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
trzeć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
trzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
trzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
trzeć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
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)}
trzepać się: _: imperf: subj{np(str)} + {xp(locat)}
trzepnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzepnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzepnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
trzepnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzepnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trzeźwieć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
tupać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
tupać: _: imperf: subj{np(str)} + {np(inst)} + {or}
tupać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
tupać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
tupać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
tupać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
tupać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
tupać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
tupać: _: imperf: subj{np(str)} + {xp(perl)}
tupnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
tupnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
tupnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
tupnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
tupnąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
twierdzić: _: imperf: subj{np(str)} + {advp(pron)}
twierdzić: _: imperf: subj{np(str)} + {cp(jakoby)}
twierdzić: _: imperf: subj{np(str)} + {cp(że)}
twierdzić: _: imperf: subj{np(str)} + {cp(żeby)}
twierdzić: _: imperf: subj{np(str)} + {nonch}
twierdzić: _: imperf: subj{np(str)} + {or}
tworzyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tworzyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
tworzyć się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
tworzyć się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
tyć: _: imperf: subj{np(str)} + {comprepnp(z powodu)}
tyć: _: imperf: subj{np(str)} + {np(str)}
tyć: _: imperf: subj{np(str)} + {prepnp(na,loc)}
tyć: _: imperf: subj{np(str)} + {prepnp(o,acc)}
tyć: _: imperf: subj{np(str)} + {prepnp(od,gen)}
tyć: _: imperf: subj{np(str)} + {prepnp(z,gen)}
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)}
ubezpieczać się: _: imperf: subj{np(str)} + {prepnp(na,gen); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {xp(locat)}
ubezpieczać się: _: imperf: 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)}
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)}
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ć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ubiegać: _: imperf: 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)}
ubierać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ubierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ubierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubierać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ubierać: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ubierać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
ubierać się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
ubierać się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
ubrać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ubrać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ubrać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubrać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ubrać: _: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ubrać się: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
ubrać się: _: perf: subj{np(str)} + {prepnp(u,gen)}
ubrać się: _: perf: subj{np(str)} + {xp(locat)}
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)}
ucałować się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
uchwalić: _: perf: subj{np(str)} + {cp(że)}
uchwalić: _: perf: subj{np(str)} + {cp(żeby)}
uchwalić: _: perf: subj{np(str)} + obj{np(str)}
uchwalić: _: perf: subj{np(str)} + {or}
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}
uchwycić się: _: perf: subj{np(str)} + {np(gen)} + {np(inst)}
uchwycić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
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)}
ucichnąć: _: perf: subj{np(str)}
ucichnąć: _: perf: {xp(locat)}
uciemiężyć: _: perf: subj{np(str)} + obj{np(str)} + {np(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ć: _: perf: subj{cp(że)} + {np(str)}
ucieszyć: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)}
ucieszyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ucieszyć się: _: perf: subj{np(str)} + {cp(że)}
ucieszyć się: _: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
ucieszyć się: _: perf: subj{np(str)} + {or}
ucieszyć się: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
uczcić: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
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)}
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)}
uczulać się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
uczulać się: _: imperf: 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)}
uczulić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
uczulić się: _: perf: subj{np(str)} + {prepnp(od,gen)}
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}
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}
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)}
uczynić się: _: perf: {np(dat)} + {xp(locat)} + {advp(misc)}
uczynić się: _: perf: subj,controller{np(str)} + controllee{adjp(pred)}
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)}
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)}
udaremnić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
udusić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
udusić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
udzielać: _: imperf: subj{np(str)} + obj{np(gen)} + {np(dat)}
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)}
udzielić: _: perf: 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)}
udźwignąć: _: perf: subj{np(str)} + obj{np(str)}
ufać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
ufać: _: imperf: subj{np(str)} + {np(dat); ncp(dat,że)}
ufać: _: imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
uformować: _: 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)}
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)}
ufundować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ufundować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ugasić: _: 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)}
ugasić się: _: perf: subj{np(str)}
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)}
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)}
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)}
uginać się: _: perf: subj{np(str)} + {prepnp(od,gen)}
uginać się: _: perf: subj{np(str)} + {prepnp(pod,inst)}
uginać się: _: perf: subj{np(str)} + {prepnp(przed,inst)}
ugotować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ugotować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
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)}
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}
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)}
uiścić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ujawnić: _: perf: subj{np(str)} + obj{cp(int); cp(że)} + {np(dat)}
ujawnić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ujawnić się: _: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
ujawnić się: _: perf: subj{np(str)} + {np(dat)}
ujawnić się: _: perf: subj{np(str)} + {xp(locat)}
ujawnić się: _: perf: subj{np(str)} + {xp(temp)}
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}
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}
ujeździć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ujeździć się: _: perf: subj{np(str)} + {prepnp(po,loc)}
ujeżdżać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
ujeżdżać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ujeżdżać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
ujmować: _: 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}
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}
ujrzeć: _: perf: subj{np(str)} + {cp(int)}
ujrzeć: _: perf: subj{np(str)} + {cp(jak)}
ujrzeć: _: perf: subj{np(str)} + {cp(że)}
ujrzeć: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'oko',batr)}
ujrzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ukarać: _: perf: subj{np(str)} + {np(inst)} + {prepncp(za,acc,że)} + {refl}
ukarać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
ukarać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepncp(za,acc,że)}
ukarać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ukazać: _: 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)}
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)}
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)}
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)}
układać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
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ł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{infp(_)}
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)}
ukończyć: _: perf: subj{np(str)} + obj{np(str)}
ukraść: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ukryć: _: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {prepnp(przed,inst)} + {xp(locat)}
ukryć: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
ukryć: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
ukrywać: _: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {prepnp(przed,inst)} + {xp(locat)}
ukrywać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'sobie',natr)}
ukrywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
ukrywać: _: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
ukrywać: _: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
ukrywać się: _: imperf: subj{np(str)} + {prepnp(pod,inst)}
ukrywać się: _: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
ukształtować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ukształtować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ukształtować się: _: perf: subj{np(str)} + {np(inst)}
ukształtować się: _: perf: subj{np(str)} + {xp(locat)}
ulatniać się: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ulec: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ulec: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ulec: _: perf: subj{np(str)} + {np(dat); ncp(dat,że)}
ulec: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulegać: _: imperf: subj{cp(int)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: _: imperf: subj{cp(int)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: _: imperf: subj{cp(że)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: _: imperf: subj{cp(że)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ulegać: _: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ulegać: _: imperf: subj{np(str)} + {np(dat); ncp(dat,że)}
ulegać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulokować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
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)}
ulokować się: _: perf: subj{np(str)} + {prepnp(u,gen)}
ulokować się: _: perf: subj{np(str)} + {xp(locat)}
ulotnić się: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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ć: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
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)}
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{infp(_)}
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)}
umarzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
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)}
umieć: _: imperf: subj,controller{np(str)} + controllee{np(str); infp(_)}
umieć: _: imperf: subj{np(str)} + {prepadjp(po,postp)}
umiejscawiać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umiejscawiać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
umiejscowić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umiejscowić się: _: perf: subj{np(str)} + {np(dat)} + {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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umieszczać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
umieszczać się: _: imperf: 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)}
umieścić się: _: perf: subj{np(str)} + {xp(locat)}
umilać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umilić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umilknąć: _: perf: subj{np(str)}
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)}
umknąć: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
umożliwiać: _: imperf: subj{ncp(str,że)} + obj{np(str)}
umożliwiać: _: imperf: subj{np(str)} + {cp(że)}
umożliwiać: _: imperf: subj{np(str)} + {cp(żeby)}
umożliwiać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {infp(_)}
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)} + {cp(że)}
umożliwić: _: perf: subj{np(str)} + {cp(żeby)}
umożliwić: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {infp(_)}
umożliwić: _: perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
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)}
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)}
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)}
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)}
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)}
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)}
uniemożliwiać: _: imperf: subj{np(str)} + {cp(żeby)}
uniemożliwiać: _: imperf: subj{np(str)} + {ncp(str,żeby)}
uniemożliwiać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {infp(_)}
uniemożliwiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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)} + {np(dat)} + {np(inst)} + {infp(_)}
uniemożliwić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
unieważniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
unieważnić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uniewinniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uniewinniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uniewinniać: _: imperf: subj{np(str)} + {or} + {refl}
uniewinnić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uniewinnić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uniewinnić: _: perf: subj{np(str)} + {refl}
uniezależniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {advp(misc)}
uniezależniać się: _: imperf: 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)}
uniezależnić się: _: perf: subj{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)}
unowocześniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
unowocześniać się: _: imperf: subj{np(str)}
unowocześnić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
unowocześnić się: _: perf: subj{np(str)}
uodparniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uodparniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
uodparniać się: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
uodparniać się: _: imperf: 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)}
uodpornić się: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
uodpornić się: _: perf: subj{np(str)} + {prepnp(przeciw,dat)}
uogólniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uogólniać się: _: imperf: 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)}
uogólnić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
upadać: _: imperf: subj{np(str)} + {advp(misc)}
upadać: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
upadać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
upadać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
upadać: _: imperf: subj{np(str)} + {prepnp(na,loc)}
upadać: _: imperf: subj{np(str)} + {prepnp(pod,inst)}
upadać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
upajać: _: 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)}
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}
upamiętniać: _: imperf: subj{np(str)} + {cp(że)}
upamiętniać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
upamiętniać się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
upamiętniać się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
upamiętnić: _: perf: subj{np(str)} + {cp(że)}
upamiętnić: _: perf: 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)}
upaństwawiać: _: imperf: subj{np(str)} + obj{np(str)}
upaństwowić: _: perf: subj{np(str)} + obj{np(str)}
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)}
upaść się: _: perf: subj{np(str)} + {np(inst)}
upaść się: _: perf: subj{np(str)} + {prepnp(na,loc)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
upchać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
upchać się: _: perf: subj{np(str)} + {xp(adl)}
upchać się: _: perf: subj{np(str)} + {xp(locat)}
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)}
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)}
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)}
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)}
upić: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
upić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
upić się: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
upić się: _: perf: subj{np(str)} + {np(inst)}
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)}
upiec się: _: perf: {np(dat)}
upiec się: _: perf: subj{np(str)} + {prepnp(na,loc)}
upiec się: _: perf: subj{np(str)} + {prepnp(w,loc)}
upierać się: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
upierać się: _: imperf: subj{np(str)} + {cp(że)}
upierać się: _: imperf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)}
upierać się: _: imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)} + {or}
upijać: _: imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
upijać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
upijać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
upijać się: _: imperf: subj{np(str)} + {np(inst)}
uplasować: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uplasować się: _: perf: subj{np(str)} + {xp(locat)}
upłynąć: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
upłynąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
upłynąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
upłynąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(wśród,gen)}
upłynąć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
upłynąć: _: perf: subj{np(str)} + {np(str)}
upłynąć: _: perf: subj{np(str)} + {xp(temp)}
upływać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
upływać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
upływać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
upływać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(wśród,gen)}
upływać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
upływać: _: imperf: subj{np(str)} + {xp(temp)}
upodabniać: _: 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)}
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)}
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)}
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)}
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)}
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)}
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)}
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}
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)}
upokarzać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
upokarzać się: _: imperf: 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)}
upokorzyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
upokorzyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
upominać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
upominać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {or}
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)}
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)}
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)}
uporać się: _: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że); prepncp(z,inst,żeby)}
uporządkować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uporządkować się: _: perf: subj{np(str)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
upowszechniać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upowszechniać się: _: imperf: subj{np(str)} + {prepnp(wśród,gen)}
upowszechniać się: _: imperf: subj{np(str)} + {xp(locat)}
uprawniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
uprościć: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
uprościć się: _: perf: subj{np(str)}
uprzeć się: _: perf: subj,controller{np(str)} + controllee{infp(_)}
uprzeć się: _: perf: subj{np(str)} + {cp(że)}
uprzeć się: _: perf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)} + {or}
uprzeć się: _: perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)} + {or}
uprzedzać: _: 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)}
uprzedzać się: _: imperf: 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)}
uprzedzić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
uprzemysłowić: _: perf: subj{np(str)} + obj{np(str)}
uprzemysłowić się: _: perf: subj{np(str)}
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)}
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)}
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)}
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)}
upuścić: _: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(z,gen)}
upuścić: _: perf: subj{np(str)} + obj{np(str)}
upychać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
upychać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
upychać się: _: imperf: subj{np(str)} + {xp(adl)}
upychać się: _: imperf: subj{np(str)} + {xp(locat)}
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}
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)}
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}
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)}
urodzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
uroić: _: perf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
uroić: _: perf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
uroić się: _: perf: subj{cp(że)} + {np(dat)}
uroić się: _: perf: subj{np(dat)} + {np(dat)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uruchamiać się: _: imperf: subj{np(str)} + {np(dat)}
uruchomić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uruchomić się: _: perf: subj{np(str)} + {np(dat)}
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}
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)}
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}
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)}
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ądzać się: _: imperf: 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)}
urządzić się: _: perf: subj{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ć: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
urzeczywistniać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
urzeczywistniać się: _: imperf: 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)}
urzeczywistnić się: _: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
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)}
usamodzielniać: _: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
usamodzielniać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
usamodzielniać się: _: imperf: subj{np(str)} + {advp(misc)}
usamodzielniać się: _: imperf: 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)}
usamodzielnić się: _: perf: subj{np(str)} + {advp(misc)}
usamodzielnić się: _: perf: subj{np(str)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
uschnąć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
uschnąć: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
usidlić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
usiłować: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
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)}
uskrzydlać się: _: imperf: 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)}
uskrzydlić się: _: perf: subj{np(str)}
usłyszeć: _: perf: subj{np(str)} + {cp(int)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: perf: subj{np(str)} + {cp(jakoby)}
usłyszeć: _: perf: subj{np(str)} + {cp(jak)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: perf: subj{np(str)} + {cp(żeby2)}
usłyszeć: _: perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: perf: subj{np(str)} + {np(str)} + {preplexnp(na,acc,pl,'ucho',batr)}
usłyszeć: _: perf: subj{np(str)} + {np(str); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(od,gen)}
usłyszeć: _: perf: subj{np(str)} + obj{np(str); cp(int); cp(jak); cp(że); ncp(str,że)} + {np(inst)}
usłyszeć: _: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
usłyszeć: _: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(jak)}
usłyszeć: _: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
usłyszeć: _: perf: subj{np(str)} + {prepnp(od,gen)} + {or}
usłyszeć: _: perf: subj{np(str)} + {refl}
usmażyć: _: 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)}
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)}
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}
uspokajać się: _: imperf: subj{np(str)} + {cp(że)}
uspokajać się: _: imperf: 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}
uspokoić się: _: perf: subj{np(str)} + {cp(że)}
uspokoić się: _: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
uspołecznić: _: perf: subj{np(str)} + obj{np(str)}
uspołecznić się: _: perf: subj{np(str)}
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}
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}
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}
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}
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)}
usprawniać się: _: imperf: 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)}
usprawnić się: _: perf: subj{np(str)}
ustać: _: perf: subj{np(str)} + obj{np(str)}
ustać: _: perf: subj{np(str)} + {prepnp(w,loc)}
ustać się: _: perf: subj{np(str)}
ustalić: _: perf: subj{np(str)} + {cp(int); cp(że)}
ustalić: _: perf: subj{np(str)} + {cp(żeby2)}
ustalić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int)}
ustatkować się: _: perf: subj{np(str)}
ustawać: _: imperf: subj{np(str)} + obj{np(str)}
ustawać: _: imperf: subj{np(str)} + {prepnp(w,loc)}
ustąpić: _: perf: subj{np(str)} + {np(dat)} + {np(gen)}
ustąpić: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ustąpić: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
ustąpić: _: perf: subj{np(str)} + {prepnp(od,gen)}
ustąpić: _: perf: subj{np(str)} + {prepnp(przed,inst)}
ustąpić: _: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
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)}
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}
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)}
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}
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)}
usunąć: _: perf: subj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)} + {refl}
usunąć się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
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)}
usuwać: _: imperf: subj{np(str)} + {preplexnp(w,acc,sg,'cień',natr)} + {refl}
usuwać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
uszczuplać się: _: imperf: subj{np(str)} + {prepnp(o,acc)}
uszczuplić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
uszczuplić się: _: perf: subj{np(str)} + {prepnp(o,acc)}
uszkodzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uszkodzić się: _: perf: subj{np(str)} + {np(dat)}
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ściskać się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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ślać się: _: imperf: 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ściślić się: _: perf: subj{np(str)}
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świadamiać: _: imperf: subj{np(str)} + {np(dat)} + {or}
uświadamiać: _: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uświadamiać: _: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uświadamiać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(int); cp(że)}
uświadamiać: _: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uświadamiać: _: imperf: subj{np(str)} + obj{np(str)} + {or}
uświadamiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
uświadomić: _: perf: subj{np(str)} + {np(dat)} + {or}
uświadomić: _: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uświadomić: _: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uświadomić: _: perf: subj{np(str)} + obj{np(str)} + {cp(int); cp(że)}
uświadomić: _: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uświadomić: _: perf: subj{np(str)} + obj{np(str)} + {or}
uświadomić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
uś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)}
utknąć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
utknąć: _: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
utłuc: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
utonąć: _: perf: subj{np(str)} + {prepnp(w,loc)}
utopić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utopić się: _: perf: subj{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ć: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
utożsamiać się: _: imperf: 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)}
utożsamić się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
utrząść: _: perf: subj{np(str)} + obj{np(str)}
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}
utrzymać się: _: perf: subj{np(str)} + {prepnp(przy,loc)}
utrzymać się: _: perf: 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}
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)}
utwierdzać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {cp(że)}
utwierdzać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
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)}
utwierdzić: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {cp(że)}
utwierdzić: _: perf: subj{np(str); ncp(str,że)} + 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)}
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(inst)}
utykać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
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}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
uwijać się: _: imperf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
uwijać się: _: imperf: subj{np(str)} + {xp(locat)}
uwikłać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uwikłać się: _: perf: subj{np(str)} + {prepnp(w,acc)}
uwikłać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
uwinąć się: _: perf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
uwłaszczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
uwłaszczyć się: _: perf: subj{np(str)} + {prepnp(na,loc)}
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)}
uwolnić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
uwspółcześniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwspółcześniać się: _: imperf: subj{np(str)}
uwspółcześnić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uwspółcześnić się: _: perf: subj{np(str)}
uwzględniać: _: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,inst)}
uwzględnić: _: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,inst)}
uwziąć się: _: perf: subj,controller{np(str)} + controllee{infp(_)}
uwziąć się: _: perf: subj{np(str)} + {cp(że)}
uwziąć się: _: perf: subj{np(str)} + {cp(żeby)}
uwziąć się: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uzależniać: _: 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żniać się: _: imperf: 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)}
uzależnić się: _: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,ż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}
uzdrawiać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uzdrawiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uzdrowić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uzdrowić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uzgadniać: _: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(z,inst)}
uzgadniać: _: imperf: subj{np(str)} + obj{ncp(str,int)} + {prepnp(z,inst)}
uzgadniać: _: imperf: subj{np(str)} + obj{np(str); cp(int)} + {prepnp(z,inst)}
uzgadniać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {ncp(str,że)}
uzgodnić: _: perf: subj{np(str)} + obj{cp(że)} + {prepnp(z,inst)}
uzgodnić: _: perf: subj{np(str)} + obj{ncp(str,że)} + {prepnp(z,inst)}
uzgodnić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uzgodnić: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
uzgodnić: _: perf: subj{np(str)} + {prepnp(z,inst)} + {ncp(str,int)}
uznać: _: perf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
uznać: _: perf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{adjp(inst)}
uznać: _: perf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{prepadjp(za,acc)}
uznać: _: perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
uznać: _: perf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uznać: _: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
uznać: _: perf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uznać: _: perf: subj{np(str)} + controller{cp(że)} + controllee{prepadjp(za,acc)}
uznać: _: perf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(za,acc)}
uznać: _: perf: subj{np(str)} + {cp(int)}
uznać: _: perf: subj{np(str)} + {cp(żeby)}
uznać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uznać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uznać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
uznać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
uznać: _: perf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepnp(za,acc)}
uznać: _: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
uznać: _: perf: subj{np(str)} + obj{cp(że)}
uznawać: _: imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
uznawać: _: imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
uznawać: _: imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uznawać: _: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uznawać: _: imperf: subj,controller{np(str)} + obj,controllee,controller2{infp(_)} + controllee2{prepnp(za,acc)}
uznawać: _: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepadjp(jako,str)}
uznawać: _: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(jako,str)}
uznawać: _: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(za,acc)}
uznawać: _: imperf: subj{np(str)} + {cp(int)}
uznawać: _: imperf: subj{np(str)} + {cp(żeby)}
uznawać: _: imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
uznawać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uznawać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uznawać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
uznawać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
uznawać: _: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepnp(za,acc)}
uznawać: _: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
uznawać: _: imperf: subj{np(str)} + obj{cp(że)}
uzupełnić: _: perf: subj{np(str)} + {cp(że)}
uzupełnić: _: perf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uzupełnić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzupełnić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
uzupełnić: _: perf: subj{np(str)} + {or}
uzyskać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uzyskiwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
użalać się: _: imperf: subj{np(str)} + {np(dat)} + {cp(int); cp(że)}
użalać się: _: imperf: subj{np(str)} + {np(dat)} + {or}
użalać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
użalać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
użalać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
użalać się: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
użalać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
użalać się: _: imperf: subj{np(str)} + {prepnp(nad,inst)} + {cp(że)}
użalać się: _: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(przed,inst)}
użalać się: _: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int); cp(że)}
użalać się: _: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
uż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)}
wahać: _: imperf: subj{np(str)} + {np(inst)}
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)}
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ć: _: 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,acc)} + {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,acc)}
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)}
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)}
wałęsać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wałęsać się: _: imperf: subj{np(str)} + {xp(locat)}
warto: _: imperf: {cp(żeby)}
warto: _: imperf: {infp(_)}
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}
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)}
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ć: _: perf: subj{np(str)} + {cp(żeby)}
wbić: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wbić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)} + {refl}
wbić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wbić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wbić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wbić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wbić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,acc)}
wbić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepnp(w,acc)}
wbić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
wbijać: _: imperf: subj{np(str)} + {cp(żeby)}
wbijać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wbijać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wbijać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)} + {refl}
wbijać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wbijać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wbijać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wbijać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wbijać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepnp(na,acc)}
wbijać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
wbijać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wbudować: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wbudować: _: perf: subj{np(str)} + obj{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ł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ł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)}
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)}
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)}
wchodzić: _: imperf: subj{np(str)} + {xp(perl)}
wchodzić: _: imperf: subj{np(str)} + {xp(temp)} + {preplexnp(w,acc,sg,'życie',natr)}
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ągać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
wciągać się: _: imperf: 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)}
wciągnąć się: _: perf: subj{np(str)} + {prepnp(do,gen)}
wciągnąć się: _: perf: 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)}
wcielać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
wcielać się: _: imperf: 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)}
wcielić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
wcielić się: _: perf: subj{np(str)} + {prepnp(w,acc)}
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)}
wdać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wdawać się: _: imperf: subj{np(str)} + {np(dat)} + {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)}
wdrażać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
wdrażać się: _: imperf: 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)}
wdrożyć się: _: perf: subj{np(str)} + {prepnp(do,gen)}
wdrożyć się: _: perf: subj{np(str)} + {prepnp(w,acc)}
wdychać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wdychać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wdychać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
wdzierać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)}
wdzierać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
wdzierać się: _: imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wegetować: _: imperf: subj{np(str)} + {xp(locat)}
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)}
wejść: _: perf: subj{np(str)} + {xp(perl)}
wejść: _: perf: subj{np(str)} + {xp(temp)} + {preplexnp(w,acc,sg,'życie',natr)}
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)} + {np(inst)}
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)} + {xp(locat)}
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)}
wesprzeć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wesprzeć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
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}
wetować: _: imperf: subj{np(str)} + {np(inst)} + {np(str)} + {lexnp(dat,_,'siebie',natr)}
wetować: _: imperf: subj{np(str)} + obj{np(str)}
wezwać: _: perf: subj{np(str)} + {np(gen)} + {np(inst)}
wezwać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wezwać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wezwać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {xp(adl)}
wezwać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
wezwać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
wę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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wędzić się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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)} + {prepncp(o,loc,jakoby)} + {nonch}
wiadomo: _: imperf: {np(dat)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
wiadomo: _: imperf: {prepnp(z,inst)} + {nonch} + {fixed('nigdy')}
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)}
wiązać się: _: imperf: subj{np(str)} + {np(inst)}
wiązać się: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wiązać się: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
widać: _: imperf: {cp(jak); cp(że)}
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)}
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(jak)} + {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)} + {infp(_)} + {lexnp(str,sg,'potrzeba',atr)}
widzieć: _: imperf: subj{np(str)} + {infp(_)} + {lexnp(str,sg,'powód',atr)}
widzieć: _: imperf: subj{np(str)} + {infp(_)} + {lexnp(str,sg,'problem',atr)}
widzieć: _: imperf: subj{np(str)} + {infp(_)} + {lexnp(str,sg,'sens',atr)}
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)} + {np(inst)}
widzieć: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
widzieć: _: imperf: subj{np(str)} + {xp(locat)} + {refl}
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)}
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)}
wieńczyć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wierzgać: _: imperf: subj{np(str)} + {np(inst)}
wierzgać: _: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,że)}
wieszać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wieszać: _: imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
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)}
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)}
wieść się: _: imperf: controller{np(dat)} + controllee{xp(mod)} + {prepnp(w,loc)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wietrzyć się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
wikłać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wikłać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
wikłać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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(_)}
wiosłować: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wiosłować: _: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
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ć: _: 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)}
witać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
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)}
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)}
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ć: _: 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ęcać się: _: imperf: 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}
wkręcić się: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
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)}
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)}
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)}
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)}
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)}
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: _: 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)}
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)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wlepiać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wlepić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wlepić się: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
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)}
wliczać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wliczać się: _: imperf: 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)}
wliczyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wliczyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,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łamać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc)}
włamywać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
włamywać: _: 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łączać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
włączać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
włączać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
włączać się: _: imperf: 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łączyć się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
włączyć się: _: perf: subj{np(str)} + {prepnp(w,acc)} + {or}
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ć: _: 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)}
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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wmieszać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wmieszać się: _: perf: subj{np(str)} + {prepnp(do,gen)}
wmieszać się: _: perf: subj{np(str)} + {prepnp(w,acc)}
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}
wmusić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wmusić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wmuszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wmuszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wnieść: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
wnieść: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'obrady',atr)}
wnieść: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'adres',ratr)}
wnieść: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); prepncp(w,acc,int); prepncp(w,acc,że); prepncp(w,acc,żeby)}
wnieść: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)} + {xp(adl)}
wnieść: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
wnieść: _: perf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)} + {prepnp(w,loc)}
wnieść: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wnieść: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wnieść: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wnieść: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wnieść: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wnieść: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {nonch}
wnieść: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wnieść: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wnieść: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wnieść: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {nonch}
wnikać: _: imperf: subj{np(str)} + {cp(int)}
wnikać: _: imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wnikać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wniknąć: _: perf: subj{np(str)} + {cp(int)}
wniknąć: _: perf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int); prepncp(w,acc,że)}
wniknąć: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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}
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)}
wodzić się: _: imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
wodzić się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
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{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)} + {infp(_)}
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)}
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{infp(_)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: _: imperf: subj{np(str)} + {cp(int)}
wpadać: _: imperf: subj{np(str)} + {cp(że)}
wpadać: _: imperf: subj{np(str)} + {cp(żeby)}
wpadać: _: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wpadać: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wpadać: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
wpadać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wpadać: _: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
wpadać: _: imperf: subj{np(str)} + {prepnp(pod,acc)}
wpadać: _: imperf: subj{np(str)} + {prepnp(z,inst)}
wpajać: _: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wpajać: _: imperf: subj{np(str)} + obj{cp(int)} + {prepnp(w,acc)}
wpajać: _: imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wpajać: _: imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(w,acc)}
wpajać: _: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wpajać: _: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(w,acc)}
wpajać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
wpajać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,acc)}
wpaść: _: perf: subj{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{infp(_)} + {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)}
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)}
wpisać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wpisać się: _: perf: 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)}
wpisywać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wpisywać się: _: imperf: 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ątać się: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wplątać się: _: perf: 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)}
wplątywać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wplątywać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
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)}
wprawiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprawiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprawiać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprawiać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
wprawiać się: _: imperf: 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)}
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)}
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)} + {prepnp(do,gen)}
wprowadzać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wprowadzać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
wprowadzać się: _: imperf: 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)} + {prepnp(do,gen)}
wprowadzić: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wprowadzić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
wprowadzić się: _: perf: subj{np(str)} + {xp(adl)}
wpuszczać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpuszczać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpuszczać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
wpuścić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpuścić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpuścić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
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)}
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)}
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,że)}
wręczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
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ó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óż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)}
wrzucać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wrzucać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(inst,sg,'łopata',natr)} + {preplexnp(do,gen,sg,'głowa',natr)}
wrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,sg,'łopata',natr)} + {preplexnp(do,gen,sg,'głowa',natr)}
wrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'siebie',natr)}
wrzucać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wrzucić: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wrzucić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wrzucić: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'siebie',natr)}
wsadzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wsadzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsadzać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wsadzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wsadzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsadzić: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wsiadać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wsiadać: _: imperf: subj{np(str)} + {prepnp(do,gen)}
wsiadać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wsiadać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wsiadać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {or}
wsiadać: _: imperf: subj{np(str)} + {prepnp(w,acc)}
wsiąkać: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wsiąkać: _: imperf: subj{np(str)} + {prepnp(w,acc)}
wsiąknąć: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)} + {xp(perl)}
wsiąknąć: _: perf: subj{np(str)} + {prepnp(w,acc)}
wsiąść: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wsiąść: _: perf: subj{np(str)} + {prepnp(do,gen)}
wsiąść: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wsiąść: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wsiąść: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wsiąść: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {or}
wsiąść: _: perf: subj{np(str)} + {prepnp(w,acc)}
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)} + {preplexnp(do,gen,sg,'głowa',natr)}
wskoczyć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wskoczyć: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wskoczyć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wskrzesić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wskrzesić: _: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wskrzesić się: _: perf: 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}
wskrzeszać się: _: imperf: subj{np(str)}
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)}
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)}
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)}
wspinać się: _: imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(adl)}
wspomagać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)} + {refl}
wspomagać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {refl}
wspomagać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wspomagać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wspominać: _: imperf: subj{np(str)} + {np(dat)} + {or}
wspominać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
wspominać: _: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wspominać: _: imperf: subj{np(str)} + obj{cp(jak)}
wspominać: _: imperf: subj{np(str)} + obj{cp(żeby2)}
wspominać: _: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wspominać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
wspomnieć: _: perf: subj{np(str)} + {np(dat)} + {or}
wspomnieć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,jak); prepncp(o,loc,że)}
wspomnieć: _: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wspomnieć: _: perf: subj{np(str)} + obj{cp(jak)}
wspomnieć: _: perf: subj{np(str)} + obj{cp(żeby2)}
wspomnieć: _: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wspomnieć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
wspomóc: _: perf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)} + {refl}
wspomóc: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {refl}
wspomóc: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wspomóc: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
współczuć: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
współczuć: _: imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,int); ncp(gen,że)}
współczuć: _: imperf: subj{np(str)} + {prepnp(z,inst)}
współdziałać: _: imperf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
współdziałać: _: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
współgrać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {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ółtworzyć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
współżyć: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,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)}
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)}
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)}
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)}
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)}
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)}
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,gen)}
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)}
wszcząć: _: perf: subj{np(str)} + obj{np(str)}
wszcząć się: _: perf: subj{np(str)} + {xp(locat)}
wściec: _: perf: subj{cp(że)} + {np(str)}
wściec: _: perf: subj{np(str); ncp(str,że)} + {np(str)}
wściec się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
wściec się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(gdy)}
wściec się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(jak)}
wściec się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(kiedy)}
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)}
wtargnąć: _: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wtórować: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wtórować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wtrącać: _: 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ą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ą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}
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)}
wybaczać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); 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,że)}
wybaczyć: _: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wybaczyć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wybałuszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybałuszać się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
wybałuszyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybałuszyć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
wybełkotać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wybełkotać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wybełkotać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wybełkotać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wybełkotać: _: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wybetonować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
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)}
wybiec: _: perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
wybiec: _: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
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ć: _: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
wybiegać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wybiegać: _: imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wybiegać: _: imperf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'myśl',natr)}
wybiegać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wybiegać się: _: perf: subj{np(str)} + {xp(locat)}
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)}
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)}
wybijać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(z,gen,_,'głowa',atr)}
wybijać: _: perf: subj{np(str)} + {np(dat)} + {xp(perl)}
wybijać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {preplexnp(z,gen,_,'głowa',atr)}
wybijać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wybijać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wybijać: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pień',natr)}
wybijać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
wybijać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wybijać: _: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wybijać: _: perf: subj{np(str)} + {prepnp(w,loc)} + {or}
wybijać się: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wybijać się: _: perf: subj{np(str)} + {prepnp(na,acc)}
wybijać się: _: perf: subj{np(str)} + {prepnp(na,loc)}
wybijać się: _: perf: subj{np(str)} + {prepnp(ponad,acc)}
wybijać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
wybijać się: _: perf: subj{np(str)} + {prepnp(z,gen)}
wybijać się: _: perf: subj{np(str)} + {xp(abl)} + {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)}
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)}
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)}
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}
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}
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)}
wychodzić: _: perf: subj{np(str)} + obj{np(str)}
wychować: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wychować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wychować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wychować się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
wychować się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
wychować 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ć się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
wychowywać się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
wychowywać się: _: imperf: subj{np(str)} + {xp(locat)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyciągać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); xp(adl)}
wyciągać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyciągać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyciągać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyciągać się: _: imperf: subj{np(str)} + {xp(locat)}
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)}
wyciągnąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyciągnąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyciągnąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyciągnąć się: _: perf: subj{np(str)} + {xp(locat)}
wycinać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(abl)}
wycinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wycinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wycinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wycinać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wycinać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(co do,gen,sg,'noga',natr)}
wycinać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'noga',natr)}
wyciskać: _: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(z,gen)}
wyciskać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wyciskać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyciskać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyciskać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyciskać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyciskać: _: imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wyciskać: _: imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wyciskać: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wyciskać: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wycisnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)} + {prepnp(z,gen)}
wycisnąć: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wycisnąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wycisnąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wycisnąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wycisnąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycisnąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wycisnąć: _: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wycisnąć: _: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wycisnąć: _: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wycisnąć: _: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wycofać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycofać: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
wycofywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycofywać: _: imperf: 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)}
wyczuć: _: perf: subj{np(str)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',natr)}
wyczuć: _: perf: subj{np(str)} + {np(inst)} + {cp(int)}
wyczuć: _: perf: subj{np(str)} + {np(inst)} + {cp(że)}
wyczuć: _: perf: subj{np(str)} + {np(str)} + {preplexnp(przez,acc,sg,'skóra',natr)}
wyczuć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyczuć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyczuwać: _: imperf: subj{np(str)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',natr)}
wyczuwać: _: imperf: subj{np(str)} + {np(inst)} + {cp(int)}
wyczuwać: _: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
wyczuwać: _: imperf: subj{np(str)} + {np(str)} + {preplexnp(przez,acc,sg,'skóra',natr)}
wyczuwać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyczuwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyczyniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wyczytać: _: perf: subj{np(str)} + obj{cp(int)} + {prepnp(z,gen)}
wyczytać: _: perf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
wyczytać: _: perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(z,gen)}
wyczytać: _: perf: subj{np(str)} + obj{cp(żeby)} + {xp(locat)}
wyczytać: _: perf: subj{np(str)} + obj{cp(że)} + {comprepnp(na temat)} + {xp(locat)}
wyczytać: _: perf: subj{np(str)} + obj{cp(że)} + {prepnp(o,loc)} + {xp(locat)}
wyczytać: _: perf: subj{np(str)} + obj{cp(że)} + {prepnp(z,gen)}
wyczytać: _: perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
wyczytać: _: perf: subj{np(str)} + obj{nonch} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
wyczytać: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int)}
wyczytać: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
wyczytać: _: perf: subj{np(str)} + {prepnp(z,gen)} + {or}
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)}
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ąż')}
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ąż')}
wydarzyć się: _: perf: subj{cp(że)}
wydarzyć się: _: perf: subj{np(str)} + {np(dat)} + {xp(temp)}
wydarzyć się: _: perf: subj{np(str)} + {xp(locat)}
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)}
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ąż')}
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ąż')}
wydąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wydąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydąć się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
wydłużać: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydłużać się: _: imperf: 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)}
wydłużyć się: _: perf: subj{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)}
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)}
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)}
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)}
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)}
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)}
wydostać się: _: perf: subj{np(str)} + {prepnp(z,gen)}
wydostać się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
wydymać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wydymać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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ć się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
wydziedziczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydziedziczyć: _: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wydzielać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
wydzielać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
wydzielić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
wydzielić się: _: perf: subj{np(str)} + {prepnp(z,gen)}
wydzierżawić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wydzierżawić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wyeliminować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyemigrować: _: perf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wyginąć: _: perf: subj{np(str)} + {comprepnp(z powodu)} + {xp(temp)}
wyglądać: _: imperf: {cp(że)}
wyglądać: _: imperf: {prepncp(na,acc,że)}
wyglądać: _: imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {np(dat)}
wyglądać: _: imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(dat)}
wyglądać: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
wyglądać: _: imperf: subj{np(str)} + {np(gen)}
wyglądać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
wyglądać: _: imperf: subj{np(str)} + {prepnp(przez,acc)}
wygłaszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygłaszać: _: imperf: subj{np(str)} + {or}
wygłosić: _: imperf: subj{np(str)} + {cp(że)}
wygłosić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygłosić: _: imperf: subj{np(str)} + {or}
wygrać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygrać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
wygrać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wygrać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wygrać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wygrać: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
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)}
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)}
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)}
wyidealizować: _: perf: subj{np(str)} + obj{np(str)}
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ł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ł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ł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ś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ś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ś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}
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)}
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)}
wyjawiać się: _: imperf: subj{cp(że)}
wyjawiać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
wyjawiać się: _: imperf: 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)}
wyjawić się: _: perf: subj{cp(że)}
wyjawić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
wyjawić się: _: perf: subj{np(str)} + {xp(abl)}
wyjąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyjąć: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(spod,gen,sg,'prawo',atr)}
wyjąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyjąkać: _: perf: subj{np(str)} + {cp(int)}
wyjąkać: _: perf: subj{np(str)} + {cp(że)}
wyjąkać: _: perf: subj{np(str)} + {cp(żeby)}
wyjąkać: _: perf: subj{np(str)} + obj{np(str)}
wyjąkać: _: perf: subj{np(str)} + {or}
wyjechać: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wyjechać: _: perf: subj{np(str)} + {prepnp(do,gen)}
wyjechać: _: perf: subj{np(str)} + {prepnp(na,acc)}
wyjechać: _: perf: subj{np(str)} + {prepnp(od,gen)}
wyjechać: _: perf: subj{np(str)} + {xp(abl)}
wyjechać: _: perf: subj{np(str)} + {xp(adl)}
wyjeż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)}
wyjeżdżać: _: perf: subj{np(str)} + obj{np(str)}
wyjeżdżać się: _: perf: subj{np(str)}
wyjmować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyjmować: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(spod,gen,sg,'prawo',atr)}
wyjmować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyjść: _: perf: {prepadjp(na,acc)}
wyjść: _: perf: {prepncp(na,acc,że)}
wyjść: _: perf: {prepnp(na,acc)}
wyjść: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen)}
wyjść: _: perf: subj,controller{np(str); ncp(str,że)} + controllee{prepadjp(na,acc)} + {np(dat)}
wyjść: _: perf: subj{cp(że)} + {advp(misc)}
wyjść: _: perf: subj{cp(że)} + {np(dat)} + {prepadjp(na,acc)}
wyjść: _: perf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
wyjść: _: perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyjść: _: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'bok',natr)}
wyjść: _: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepadjp(na,acc)}
wyjść: _: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(z,gen)}
wyjść: _: perf: subj{np(str)} + {np(dat)} + {advp(misc)}
wyjść: _: perf: subj{np(str)} + {np(dat)} + {lexnp(inst,_,'ucho',natr)}
wyjść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'korzyść',natr)}
wyjść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'spotkanie',natr)}
wyjść: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'zdrowie',natr)}
wyjść: _: perf: subj{np(str)} + {prepnp(do,gen)}
wyjść: _: perf: subj{np(str)} + {prepnp(na,acc); xp(adl)} + {xp(abl)} + {xp(perl)}
wyjść: _: perf: subj{np(str)} + {prepnp(od,gen)}
wyjść: _: perf: subj{np(str)} + {prepnp(poza,acc)}
wyjść: _: perf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wyjść: _: perf: subj{np(str)} + {prepnp(z,inst)}
wykańczać: _: 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)}
wykańczać się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
wykarczować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wykarczować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
wykazać: _: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
wykazać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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}
wykazywać się: _: imperf: subj{np(str)} + {np(inst)} + {or}
wykąpać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykąpać: _: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
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)}
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)}
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ć: _: 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)}
wykonać się: _: perf: 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)}
wykonywać się: _: imperf: subj{np(str)}
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)}
wykończyć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
wykopać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wykopać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wykopać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykopać: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wykopać: _: perf: subj{np(str)} + {xp(abl)} + {refl}
wykorzystać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wykorzystać: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wykorzystać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {cp(żeby)}
wykorzystać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wykorzystać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
wykorzystać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykorzystywać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wykorzystywać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wykorzystywać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {cp(żeby)}
wykorzystywać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wykorzystywać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
wykorzystywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykosztować się: _: perf: subj{np(str)} + {prepnp(na,acc)}
wykpić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
wykpiwać: _: imperf: 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)}
wykraczać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {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)}
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ślić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykreślić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykreślić: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
wykryć się: _: perf: subj{cp(że)}
wykryć się: _: perf: 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)}
wykrywać się: _: imperf: subj{np(str)}
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}
wykrzyczeć się: _: perf: subj{np(str)} + {prepnp(na,acc)}
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}
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}
wykupić się: _: perf: 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}
wykupywać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wylądować: _: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
wylądować: _: perf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
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)}
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)}
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)}
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)}
wyliczać się: _: imperf: 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)}
wyliczyć się: _: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
wyludniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyludniać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
wyludnić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyludnić się: _: perf: subj{np(str)} + {prepnp(z,gen)}
wyluzować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyluzować: _: perf: subj{np(str)} + {prepnp(z,inst)}
wyluzować się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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ł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ł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ł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łamać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
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łamywać: _: imperf: 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ł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łaniać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
wyłaniać się: _: imperf: subj{np(str)} + {xp(abl)}
wyłazić: _: perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyłazić: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyłazić: _: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
wyłazić: _: perf: subj{np(str)} + {prepnp(z,gen)}
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łonić się: _: perf: subj{np(str)} + {prepnp(z,gen)}
wyłonić się: _: perf: subj{np(str)} + {xp(abl)}
wyłudzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyłudzić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyłuskać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyłuskiwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
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)}
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)}
wymawiać się: _: imperf: subj{np(str)} + {or}
wymawiać się: _: imperf: subj{np(str)} + {prepnp(od,gen)}
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}
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)}
wymieniać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wymieniać się: _: imperf: 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)}
wymienić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wymienić się: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wymieszać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
wyminąć: _: perf: subj{np(str)} + obj{np(str)}
wyminąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wyminąć się: _: perf: subj{np(str)} + {xp(locat)}
wymiotować: _: imperf: subj{np(str)} + {np(inst)}
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)}
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)}
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}
wymyć się: _: perf: subj{np(str)} + {xp(abl)}
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)}
wymyślać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
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{ncp(str,że)}
wymyślić: _: perf: subj{np(str)} + obj{np(str)}
wymyślić: _: perf: subj{np(str)} + {or}
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)}
wynająć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wynająć się: _: perf: 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)}
wynajmować się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wynajmować się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wynaradawiać: _: imperf: subj{np(str)} + obj{np(str)}
wynaradawiać się: _: imperf: subj{np(str)}
wynarodowić: _: perf: subj{np(str)} + obj{np(str)}
wynarodowić się: _: perf: subj{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ść: _: 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)}
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)}
wynikać: _: imperf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wyniknąć: _: perf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wynosić: _: 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)}
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)}
wynurzać: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzać się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzyć: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzyć się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyobrazić: _: perf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrazić: _: perf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrazić: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: _: imperf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: _: imperf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
wyodrębniać: _: 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ę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ę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)}
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)}
wyolbrzymić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
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)}
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ć: _: 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)}
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)}
wypchnąć: _: 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)}
wypełniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypełniać się: _: imperf: subj{np(str)} + {np(inst)}
wypełnić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypełnić się: _: perf: subj{np(str)} + {np(inst)}
wypełzać: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wypełzać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypełznąć: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
wypełznąć: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypędzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypędzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wypić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wypić: _: perf: subj{np(str)} + {prepnp(na,acc)}
wypierać: _: 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)}
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}
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)}
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ątać się: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyplątać się: _: perf: 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)}
wyplątywać się: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyplątywać się: _: imperf: subj{np(str)} + {xp(abl)}
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ć: _: 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)}
wypływać się: _: perf: subj{np(str)}
wypogadzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypogadzać się: _: imperf: subj{E} + {xp(locat)}
wypogadzać się: _: imperf: subj{np(str)} + {np(dat)}
wypominać: _: imperf: subj{np(str)} + {np(dat)} + {or}
wypominać: _: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wypominać: _: imperf: subj{np(str)} + obj{cp(jak)} + {np(dat)}
wypominać: _: imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wypominać: _: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wypominać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wypomnieć: _: perf: subj{np(str)} + {np(dat)} + {or}
wypomnieć: _: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wypomnieć: _: perf: subj{np(str)} + obj{cp(jak)} + {np(dat)}
wypomnieć: _: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wypomnieć: _: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wypomnieć: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wyposażać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wyposażać: _: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wyposażyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wyposażyć: _: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
wypowiadać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypowiadać: _: imperf: subj{np(str)} + obj{np(str)} + {or}
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)}
wypowiedzieć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypowiedzieć: _: perf: 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)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wypracować się: _: perf: subj{np(str)}
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)}
wyprodukować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprodukować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wyprodukować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wyprodukować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprofilować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wypromować: _: perf: subj{np(str)} + {np(inst)} + {refl}
wypromować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wypromować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wypromować: _: perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wyprosić: _: perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {xp(locat)}
wyprosić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
wyprosić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(żeby)}
wyprosić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(żeby)}
wyprosić: _: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {np(inst)} + {prepnp(u,gen)}
wyprosić: _: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
wyprosić: _: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(od,gen)}
wyprosić: _: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {xp(locat)}
wyprosić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wyprosić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wyprosić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wyprosić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wyprosić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprostować: _: perf: subj{np(str)} + {cp(że)}
wyprostować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprostować: _: perf: subj{np(str)} + obj{np(str)} + {or}
wyprostować się: _: perf: subj{np(str)} + {np(dat)}
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)}
wyprowadzać się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wyprowadzać się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wyprowadzać się: _: perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
wyprowadzać 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)}
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)}
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)}
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}
wyprzedać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyprzedać: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyprzedać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyprzedać się: _: perf: 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)}
wyprzedawać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyprzedawać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
wyprzedzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyprzedzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
wyprzedzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
wyprzedzić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyprzedzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
wyprzedzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
wypunktować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypunktować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wypunktować: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wypuszczać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypuszczać się: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypuścić: _: perf: 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)}
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)}
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)}
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)}
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)}
wyrastać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrastać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyrastać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
wyrazić: _: perf: subj{np(str)} + {cp(że)}
wyrazić: _: perf: subj{np(str)} + obj{ncp(str,że)}
wyrazić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyrazić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,że)}
wyrazić: _: perf: subj{np(str)} + {or}
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)}
wyrazić się: _: perf: 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{ncp(str,int)}
wyrażać: _: imperf: subj{np(str)} + obj{ncp(str,że)}
wyrażać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyrażać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wyrażać: _: imperf: subj{np(str)} + obj{np(str)} + {prepncp(w,loc,że)}
wyrażać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrażać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrażać się: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(przez,acc,int)}
wyrażać się: _: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
wyregulować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyregulować się: _: perf: subj{np(str)}
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)}
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)}
wyrosnąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrosnąć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyrosnąć: _: perf: subj{np(str)} + {prepnp(na,acc)}
wyrównać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
wyrównać się: _: perf: subj{np(str)} + {prepnp(do,gen)}
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ć: _: 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)}
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)}
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)}
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)}
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)}
wyrzucać: _: imperf: {np(dat)} + {np(str)}
wyrzucać: _: imperf: {np(dat)} + {or}
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)}
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(do,gen)} + {prepnp(z,gen)}
wyrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wyrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)}
wyrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {xp(abl)}
wyrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyrzucać: _: imperf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wyrzucić: _: perf: {np(dat)} + {np(str)}
wyrzucić: _: perf: {np(dat)} + {or}
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(do,gen)} + {prepnp(z,gen)}
wyrzucić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wyrzucić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)}
wyrzucić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {xp(abl)}
wyrzucić: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyrzucić: _: perf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wyschnąć: _: perf: {np(dat)} + {xp(locat)}
wyschnąć: _: perf: subj{np(str)} + {np(dat)}
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)}
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)}
wysikać: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysikać się: _: perf: subj{np(str)} + {xp(adl)}
wyskakiwać: _: imperf: subj{cp(że)} + {np(dat)}
wyskakiwać: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyskakiwać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
wyskakiwać: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wyskakiwać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyskakiwać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(perl)}
wyskakiwać: _: imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wyskakiwać: _: imperf: subj{or} + {np(dat)}
wyskoczyć: _: perf: subj{cp(że)} + {np(dat)}
wyskoczyć: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyskoczyć: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyskoczyć: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
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(perl)}
wyskoczyć: _: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wyskoczyć: _: perf: subj{or} + {np(dat)}
wysłuchać: _: perf: subj{np(str)} + obj{cp(int)}
wysłuchać: _: perf: subj{np(str)} + obj{cp(jak)}
wysłuchać: _: perf: subj{np(str)} + obj{cp(że)}
wysłuchać: _: perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)}
wysłuchać: _: perf: subj{np(str)} + obj{np(str)}
wysłuchiwać: _: imperf: subj{np(str)} + obj{cp(int)}
wysłuchiwać: _: imperf: subj{np(str)} + obj{cp(jak)}
wysłuchiwać: _: imperf: subj{np(str)} + obj{cp(że)}
wysłuchiwać: _: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)}
wysłuchiwać: _: imperf: subj{np(str)} + obj{np(str)}
wysługiwać: _: 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ługiwać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wysługiwać się: _: imperf: subj{np(str)} + {np(inst)}
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)}
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)}
wyspać się: _: perf: subj{np(str)}
wyspowiadać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
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)}
wyssać: _: perf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,sg,'palec',atr)}
wyssać: _: perf: subj{np(str)} + obj{np(str)} + {fixed('z mlekiem matki')}
wyssać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wystarać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(u,gen)}
wystarać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(u,gen)} + {cp(żeby)}
wystarać się: _: perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(u,gen)}
wystarać się: _: perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)} + {cp(żeby)}
wystarczać: _: imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc)}
wystarczać: _: imperf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
wystarczać: _: imperf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: _: imperf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: _: imperf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: _: imperf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
wystarczać: _: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
wystarczać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystarczyć: _: perf: {np(dat)} + {np(gen)} + {prepnp(na,acc)}
wystarczyć: _: perf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
wystarczyć: _: perf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: _: perf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: _: perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: _: perf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: _: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystawać: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wystawać: _: imperf: subj{np(str)} + {xp(adl)}
wystawać: _: 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}
wystawiać się: _: imperf: 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}
wystawić się: _: perf: subj{np(str)} + {xp(locat)}
wystąpić: _: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wystąpić: _: perf: subj{ncp(str,że)} + {prepnp(u,gen)}
wystąpić: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystąpić: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wystąpić: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
wystąpić: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wystąpić: _: perf: subj{np(str)} + {prepnp(na,loc)}
wystąpić: _: perf: subj{np(str)} + {prepnp(przed,inst)}
wystąpić: _: perf: subj{np(str)} + {prepnp(u,gen)}
wystąpić: _: perf: subj{np(str)} + {prepnp(w,loc)}
wystąpić: _: perf: subj{np(str)} + {prepnp(z,gen)}
występować: _: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
występować: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
występować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
występować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
występować: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
występować: _: imperf: subj{np(str)} + {prepnp(na,loc)}
występować: _: imperf: subj{np(str)} + {prepnp(przed,inst)}
występować: _: imperf: subj{np(str)} + {prepnp(u,gen)}
występować: _: imperf: subj{np(str)} + {prepnp(w,loc)}
występować: _: imperf: subj{np(str)} + {prepnp(z,gen)}
występować: _: imperf: subj{np(str)} + {xp(locat)}
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)}
wysunąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysunąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wysunąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysunąć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wysunąć się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wysuwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysuwać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wysuwać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysuwać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wysuwać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wysychać: _: imperf: {np(dat)} + {xp(locat)}
wysychać: _: imperf: subj{np(str)} + {np(dat)}
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)}
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)}
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)}
wysypywać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypywać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
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ć: _: 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)}
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)}
wyszorować: _: perf: subj{np(str)} + {np(inst)} + {refl}
wyszorować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyszukiwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wyszukiwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
wyszyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyszyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyszyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyszywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
wyszywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyszywać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyśmiać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
wyśmiać się: _: perf: subj{np(str)}
wyśmiewać: _: imperf: 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ś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ć: _: 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)}
wytaczać się: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytarmosić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wytarmosić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
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,że)} + {lexnp(inst,_,'palec',natr)}
wytknąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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ł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)}
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)}
wytoczyć się: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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ącać się: _: imperf: 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)}
wytrącić się: _: perf: subj{np(str)} + {prepnp(z,gen)}
wytropić: _: perf: subj{np(str)} + {cp(int)}
wytropić: _: perf: subj{np(str)} + {cp(że)}
wytropić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
wytropić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wytropić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wytrwać: _: perf: subj{np(str)} + {prepnp(w,loc)} + {xp(dur)}
wytrwać: _: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytwarzać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
wytworzyć: _: perf: 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)}
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,że)} + {lexnp(inst,_,'palec',natr)}
wytykać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
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)}
wywiązać się: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywiązywać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywierać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywierać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wywieść: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
wywieść: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,acc,pl,'manowiec',natr)}
wywieść: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(w,acc,sg,'pole',natr)}
wywieść: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
wywieść: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wywieść: _: perf: subj{np(str)} + {or}
wywieść: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {cp(int)}
wywieść: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {cp(że)}
wywieźć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wywieźć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wywieźć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywłaszczać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywłaszczyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywnioskować: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wywnioskować: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnioskować: _: perf: subj{np(str)} + {or}
wywnioskować: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(żeby2)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wywnioskować: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(żeby2)}
wywodzić: _: 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)}
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)}
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ć: _: 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)}
wywracać się: _: imperf: 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ócić się: _: perf: subj{np(str)} + {np(dat)}
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ższać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,acc)}
wywyższać się: _: imperf: 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)}
wywyższyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(nad,acc)}
wywyższyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(ponad,acc)}
wyzbyć się: _: perf: subj{np(str)} + {np(gen)}
wyzdrowieć: _: perf: subj{np(str)} + {prepnp(po,loc)}
wyzdrowieć: _: perf: subj{np(str)} + {prepnp(z,gen)}
wyzierać: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(perl)}
wyzierać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyziębiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyziębiać się: _: imperf: {prepnp(od,gen)} + {xp(locat)}
wyziębiać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
wyziębić: _: perf: 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)}
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ć: _: 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)}
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)}
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)}
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)}
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ć: _: 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)}
wyzwalać się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
wyzwalać się: _: imperf: 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)}
wyzwolić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
wyzwolić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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ż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ż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ż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)}
wzbić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wzbić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wzbić się: _: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wzbić się: _: perf: 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)}
wzbijać się: _: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wzbijać się: _: imperf: subj{np(str)} + {xp(locat)}
wzbudzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wzbudzać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
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)}
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)}
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ć: _: 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)}
wzmagać się: _: imperf: subj{np(str)} + {prepnp(u,gen)}
wzmagać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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: _: 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)}
wzmóc się: _: perf: subj{np(str)} + {prepnp(u,gen)}
wzmóc się: _: perf: subj{np(str)} + {prepnp(w,loc)}
wznosić: _: imperf: 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)}
wznowić: _: perf: subj{np(str)} + obj{np(str)}
wzorować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
wzorować się: _: imperf: subj{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ć: _: 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)}
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)}
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)}
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)}
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)}
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)}
zaadaptować się: _: perf: subj{np(str)} + {prepnp(do,gen)}
zaadaptować się: _: perf: subj{np(str)} + {xp(locat)}
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}
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}
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)}
zabawić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabawić: _: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
zabawić się: _: perf: subj{np(str)} + {np(inst)}
zabawić się: _: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,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)}
zabezpieczać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczać się: _: imperf: 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)}
zabezpieczyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
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)}
zabić się: _: perf: subj{np(str)} + {prepnp(o,acc)}
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ć: _: 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)}
zabiegać się: _: imperf: subj{np(str)}
zabijać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {refl}
zabijać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabijać się: _: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zabłądzić: _: perf: subj{np(str)} + {xp(adl)}
zabłądzić: _: perf: subj{np(str)} + {xp(locat)}
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)}
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)}
zabraknąć: _: perf: {np(dat)} + {np(gen)} + {cp(żeby)}
zabraknąć: _: perf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zabraknąć: _: perf: {np(dat)} + {prepnp(dla,gen)} + {lexnp(gen,pl,'słowo',atr)}
zabraknąć: _: perf: {np(dat)} + {prepnp(na,acc)} + {lexnp(gen,pl,'słowo',atr)}
zabraknąć: _: perf: {np(gen)} + {xp(locat)}
zabraniać: _: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zabraniać: _: imperf: subj{np(str)} + {np(dat)} + {ncp(gen,żeby)}
zabraniać: _: imperf: subj{np(str)} + obj,controllee{np(gen); infp(_)} + controller{np(dat)}
zabronić: _: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zabronić: _: perf: subj{np(str)} + {np(dat)} + {ncp(gen,żeby)}
zabronić: _: perf: subj{np(str)} + obj,controllee{np(gen); infp(_)} + controller{np(dat)}
zabrudzić: _: 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)}
zabrudzić się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zabrudzić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
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)}
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)}
zachcieć się: _: imperf: controller{np(dat)} + controllee{infp(_)}
zachcieć się: _: imperf: {np(dat)} + {cp(żeby)}
zachcieć się: _: imperf: {np(dat)} + {np(gen)}
zachcieć się: _: imperf: {np(dat)} + {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ć: _: 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ęcać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
zachęcić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zachęcić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zachęcić się: _: perf: subj{np(str)} + {prepnp(do,gen)}
zachłysnąć się: _: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zachłysnąć się: _: perf: subj{np(str)} + {prepnp(z,gen)}
zachłystywać się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
zachłystywać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
zachodzić: _: imperf: subj{np(str)} + {cp(int)} + {preplexnp(w,acc,sg,'głowa',natr)}
zachodzić: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zachodzić: _: imperf: subj{np(str)} + {np(dat)} + {np(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(w,acc)}
zachodzić: _: imperf: subj{np(str)} + {xp(adl)}
zachodzić: _: imperf: subj{np(str)} + {xp(locat)}
zachorować: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
zachorować: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
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}
zachować się: _: perf: subj,controller{np(str)} + controllee{xp(mod)}
zachować się: _: perf: 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}
zachowywać się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
zachowywać się: _: imperf: subj{np(str)} + {xp(locat)}
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,że)}
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)}
zachwiać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
zachwycać: _: imperf: subj{cp(int)} + {np(str)}
zachwycać: _: imperf: subj{cp(jak)} + {np(str)}
zachwycać: _: imperf: subj{cp(kiedy)} + {np(str)}
zachwycać: _: imperf: subj{cp(że)} + {np(str)}
zachwycać: _: imperf: subj{ncp(str,int)} + {np(str)}
zachwycać: _: imperf: subj{ncp(str,że)} + {np(str)}
zachwycać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycać się: _: imperf: subj{np(str)} + {cp(gdy)}
zachwycać się: _: imperf: subj{np(str)} + {cp(jak)}
zachwycać się: _: imperf: subj{np(str)} + {cp(jeśli)}
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)}
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ąć 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ąż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)}
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)}
zacierać się: _: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
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ś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ś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)}
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)}
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)}
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)}
zacząć: _: perf: subj,controller{E} + controllee{infp(imperf)}
zacząć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zacząć się: _: perf: {prepnp(od,gen); prepncp(od,gen,że)}
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)}
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ć: _: 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)}
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)}
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)}
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)}
zaczynać: _: imperf: subj,controller{E} + controllee{infp(imperf)}
zaczynać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zaczynać: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
zadać: _: perf: subj{np(str)} + {np(dat)} + {np(gen)}
zadać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadać się: _: perf: 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)}
zadawać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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ć: _: 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)}
zadecydować się: _: perf: subj{cp(int)}
zadecydować się: _: perf: subj{np(str)}
zadedykować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
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)}
zademonstrować: _: perf: subj{np(str)} + {comprepnp(na rzecz)}
zademonstrować: _: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
zademonstrować: _: perf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
zademonstrować: _: perf: subj{np(str)} + obj{cp(int)} + {prepnp(wobec,gen)}
zademonstrować: _: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zademonstrować: _: perf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
zademonstrować: _: perf: subj{np(str)} + obj{cp(że)} + {prepnp(wobec,gen)}
zademonstrować: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zademonstrować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zademonstrować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
zademonstrować: _: perf: subj{np(str)} + {prepnp(przeciw,dat)}
zademonstrować: _: perf: subj{np(str)} + {prepnp(za,inst)}
zadłużyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)}
zadłużyć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)} + {refl}
zadomowić się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadomowić się: _: perf: subj{np(str)} + {prepnp(u,gen)}
zadomowić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
zadowalać: _: 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)}
zadowalać się: _: imperf: 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)}
zadowolić się: _: perf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zadrzeć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zadrzeć: _: perf: subj{np(str)} + {prepnp(z,inst)}
zadrzeć się: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zadrżeć: _: perf: subj{lexnp(str,sg,'ręka',natr)} + {np(dat)} + {cp(żeby2)}
zadrżeć: _: perf: subj{np(str)} + {cp(czy)}
zadrżeć: _: perf: subj{np(str)} + {cp(że)}
zadrżeć: _: perf: subj{np(str)} + {cp(żeby)}
zadrżeć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zadrżeć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zadrżeć: _: perf: subj{np(str)} + {or}
zadrżeć: _: perf: subj{np(str)} + {preplexnp(w,loc,pl,'posada',natr)}
zadrżeć: _: perf: subj{np(str)} + {prepnp(nad,inst)}
zadrżeć: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zadrżeć: _: perf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,int); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
zadudnić: _: perf: {np(dat)} + {xp(locat)}
zadudnić: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zadudnić: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadudnić: _: perf: subj{np(str)} + {np(inst)} + {or}
zadudnić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zadudnić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zadudnić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zadudnić: _: perf: subj{np(str)} + {prepnp(od,gen)}
zadudnić: _: perf: subj{or} + {np(dat)} + {xp(locat)}
zadumać się: _: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,jak); prepncp(nad,inst,że)}
zadziałać: _: perf: subj{np(str)} + {comprepnp(w kwestii)}
zadziałać: _: perf: subj{np(str)} + {comprepnp(w sprawie)}
zadziałać: _: perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
zadziałać: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zadzierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zadzierać: _: imperf: subj{np(str)} + {prepnp(z,inst)}
zadzierać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zadzwonić: _: perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zadzwonić: _: perf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
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(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
zadzwonić: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
zadzwonić: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
zadzwonić: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
zadzwonić: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
zadzwonić: _: perf: subj{np(str)} + {prepnp(na,acc)}
zadźgać: _: perf: subj{np(str)} + {np(inst)} + {refl}
zadźgać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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ć: _: 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)}
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)}
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)}
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)}
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}
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)}
zaginąć: _: perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
zaglądać: _: imperf: subj{np(str)} + {cp(int)}
zaglądać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
zaglądać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaglądać: _: imperf: subj{np(str)} + {prepnp(na,acc)}
zaglądać: _: imperf: subj{np(str)} + {xp(adl)}
zagł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)}
zagospodarować: _: perf: subj{np(str)} + obj{np(str)}
zagospodarować się: _: perf: subj{np(str)} + {xp(locat)}
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)}
zagrzać się: _: perf: subj{np(str)} + {np(dat)}
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ć: _: 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)}
zagrzewać się: _: imperf: subj{np(str)} + {np(dat)}
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)}
zagwarantować: _: perf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zagwarantować: _: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
zagwarantować: _: perf: subj{np(str)} + {or}
zahaczać: _: 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)}
zahaczać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zahaczać się: _: imperf: 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)}
zahaczyć się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zahaczyć się: _: perf: subj{np(str)} + {xp(locat)}
zainicjować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
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)}
zainwestować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,żeby)}
zajadać: _: imperf: subj{np(str)} + obj{np(str)}
zajadać się: _: imperf: subj{np(str)} + {np(inst)}
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ąć się: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
zająć się: _: perf: subj{np(str)} + {prepnp(od,gen)}
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)}
zajmować się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
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)}
zakazać: _: perf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakazywać: _: imperf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakąsić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakąszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
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)}
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)}
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)}
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)}
zakładać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakładać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zakładać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zakładać: _: imperf: subj{np(str)} + {or}
zakładać się: _: imperf: subj{np(str)} + {prepnp(o,acc); 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ć się: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(o,acc,int)}
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łócać się: _: imperf: 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łócić się: _: perf: subj{np(str)} + {np(dat)}
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)}
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)}
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)}
zakołysać: _: perf: {np(inst)}
zakołysać: _: perf: subj{np(str)} + {np(inst)}
zakołysać: _: perf: subj{np(str)} + obj{np(str)}
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)}
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)}
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)}
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)}
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)}
zakrawać: _: imperf: subj{cp(int)} + {prepnp(na,acc)}
zakrawać: _: imperf: subj{cp(że)} + {prepnp(na,acc)}
zakrawać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,acc)}
zakręcić: _: 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)}
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)}
zakrwawić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zakrwawić się: _: perf: subj{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)}
zakwalifikować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zakwalifikować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zakwalifikować się: _: perf: subj{np(str)} + {prepnp(do,gen)}
zakwalifikować się: _: perf: subj{np(str)} + {prepnp(na,acc)}
zakwaterować: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakwaterować się: _: perf: subj{np(str)} + {xp(locat)}
zakwestionować: _: perf: subj{np(str)} + {cp(jakoby)}
zakwestionować: _: perf: subj{np(str)} + obj{cp(int)}
zakwestionować: _: perf: subj{np(str)} + obj{cp(że)}
zakwestionować: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zakwitnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zakwitnąć: _: perf: subj{np(str)} + {prepnp(w,loc)}
zalać: _: 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)}
zalać się: _: perf: subj{np(str)} + {np(inst)}
zalać się: _: perf: subj{np(str)} + {prepnp(w,acc)}
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ć: _: 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)}
zalecać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zalecić: _: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zalecić: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zalecić: _: perf: subj{np(str)} + {np(dat)} + {or}
zalecić: _: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
zalecić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zalegać: _: imperf: subj{np(str)} + {np(dat)} + {np(str)}
zalegać: _: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
zalegać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
zalegać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zalegać: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zalegać: _: imperf: subj{np(str)} + {np(inst)}
zalegać: _: imperf: subj{np(str)} + {np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
zalegać: _: imperf: subj{np(str)} + {prepnp(między,inst)}
zalegać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
zalegać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(wobec,gen)} + {prepnp(z,inst)}
zalegać: _: imperf: subj{np(str)} + {prepnp(w,loc)}
zalegalizować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalegalizować się: _: perf: subj{np(str)}
zalepiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalepiać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zalepić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalepić się: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
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)}
zalewać się: _: imperf: subj{np(str)} + {np(inst)}
zalewać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
zależeć: _: perf: subj{np(str)} + {np(str)}
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ładować się: _: perf: 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ładowywać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
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(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ł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ł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(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ł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ł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ł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ł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ł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łożyć: _: perf: subj{np(str)} + obj{cp(że); ncp(str,że)}
założyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
założyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
założyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
założyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
założyć się: _: perf: subj{np(str)} + {cp(int)}
założyć się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(z,inst)}
założyć się: _: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zamachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
zamachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
zamachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
zamachać: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zamachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zamachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
zamachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
zamachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
zamachać: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
zamachnąć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zamarzać: _: imperf: subj{np(str)}
zamarznąć: _: perf: subj{np(str)}
zamarzyć: _: 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)}
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)}
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)}
zamawiać się: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
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)}
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)}
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)}
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ć: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
zamierzać: _: imperf: subj{np(str)} + {nonch}
zamierzać się: _: imperf: 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)}
zamierzyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,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)}
zamieszać się: _: perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
zamieszać się: _: perf: subj{np(str)} + {prepnp(w,acc)}
zamieszczać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamieszkać: _: perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)}
zamieszkać: _: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zamieszkiwać: _: imperf: subj{np(str)} + obj{np(str)}
zamieszkiwać: _: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)}
zamieszkiwać: _: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zamieścić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamieść: _: perf: {np(inst)}
zamieść: _: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zamieść: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamieść: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zamilknąć: _: perf: subj{np(str)}
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}
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)}
zamontować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zamortyzować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zamortyzować się: _: perf: subj{np(str)} + {np(dat)}
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)}
zamówić się: _: perf: subj{np(str)} + {prepnp(do,gen)} + {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)}
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}
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)}
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ś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ś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)}
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)}
zaniechać: _: perf: subj{np(str)} + obj{np(gen)}
zaniedbać: _: perf: subj,controller{np(str)} + controllee{infp(_)}
zaniedbać: _: perf: subj{np(str)} + obj{np(gen)}
zaniedbać: _: perf: subj{np(str)} + obj{np(str)}
zaniedbać się: _: perf: 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)}
zaniedbywać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
zaniemóc: _: perf: subj{np(str)} + {prepnp(na,acc)}
zaniemóc: _: perf: subj{np(str)} + {prepnp(na,loc)}
zaniemóc: _: perf: subj{np(str)} + {prepnp(od,gen)}
zaniepokoić: _: 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)}
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)}
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)}
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)}
zaniżać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zaniżyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zanosić: _: 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)}
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)}
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ć: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zaoferować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
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)}
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)}
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)}
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)}
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)}
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}
zaostrzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaostrzać się: _: imperf: subj{np(str)} + {np(dat)}
zaostrzyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaostrzyć się: _: perf: subj{np(str)} + {np(dat)}
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)}
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)}
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)}
zapakować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapakować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapakować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zapakować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zapakować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapakować: _: imperf: subj{np(str)} + {xp(adl)} + {refl}
zapakować się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
zapakować się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
zapakować się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
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)}
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)}
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)}
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)}
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)} + 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,że)} + {np(dat)}
zapamiętać: _: perf: subj{np(str)} + {or}
zapamiętać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
zapanować: _: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
zapanować: _: perf: subj{np(str)} + {xp(locat)}
zaparkować: _: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaparkować: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaparzać: _: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
zaparzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaparzać się: _: imperf: 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)}
zaparzyć 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)}
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)}
zapełniać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapełniać się: _: imperf: subj{np(str)} + {np(inst)}
zapełnić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapełnić się: _: perf: subj{np(str)} + {np(inst)}
zapewniać: _: imperf: subj{np(str)} + obj{ncp(str,żeby)} + {np(dat)}
zapewniać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zapewniać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); cp(że); prepncp(o,loc,że)}
zapewnić: _: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zapewnić: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zapewnić: _: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zapewnić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
zapiąć: _: 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)} + {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)}
zapisać: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
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ć: _: 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)}
zaplatać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaplatać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
zaplątać: _: perf: subj{np(str)} + obj{np(str)} + {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)}
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)}
zapleść się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zapleść się: _: perf: subj{np(str)} + {prepnp(z,inst)}
zapłacić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
zapłacić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapłonąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapłonąć: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zapłonąć: _: perf: subj{np(str)} + {prepnp(od,gen)}
zapobiec: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapobiec: _: perf: subj{np(str)} + {np(inst)} + {ncp(dat,że)}
zapobiec: _: perf: subj{np(str)} + {np(inst)} + {ncp(dat,żeby)}
zapobiegać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zapobiegać: _: imperf: subj{np(str)} + {np(inst)} + {ncp(dat,że)}
zapobiegać: _: imperf: subj{np(str)} + {np(inst)} + {ncp(dat,żeby)}
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,jak); ncp(str,że)} + {np(dat)}
zapominać: _: imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(jak); cp(że); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zapominać się: _: imperf: 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,jak); ncp(str,że)} + {np(dat)}
zapomnieć: _: perf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(jak); cp(że); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zapomnieć się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
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ć się: _: imperf: subj{prepncp(na,acc,żeby2)}
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)}
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)}
zapoznać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapoznać się: _: perf: 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)}
zapoznawać się: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapragnąć: _: perf: subj,controller{np(str)} + controllee{cp(żeby); infp(_)}
zapragnąć: _: perf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
zapraszać: _: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zapraszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapraszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zapraszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {xp(adl)}
zapraszać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)} + {refl}
zaprawiać: _: 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)}
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)}
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)}
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)}
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)}
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}
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)}
zapuszczać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
zapuszczać się: _: imperf: 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)}
zapuścić się: _: perf: subj{np(str)} + {prepnp(w,acc)}
zapuścić się: _: perf: subj{np(str)} + {xp(adl)}
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)}
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}
zarabiać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zarabiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarabiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zarabiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zarastać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zarastać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarastać się: _: imperf: subj{np(str)} + {np(dat)}
zarazić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarazić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zarazić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
zarażać: _: imperf: 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)}
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)}
zarejestrować: _: perf: subj{np(str)} + {cp(int)}
zarejestrować: _: perf: subj{np(str)} + {cp(jak)}
zarejestrować: _: perf: subj{np(str)} + {cp(że)}
zarejestrować: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
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)} + {prepnp(u,gen)}
zarejestrować: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zarejestrować: _: perf: subj{np(str)} + {or}
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)} + {prepnp(u,gen)}
zarejestrować się: _: perf: subj{np(str)} + {xp(locat)}
zarekwirować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarezerwować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarezerwować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zarezerwować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaręczać: _: 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ęczać się: _: imperf: 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)}
zaręczyć się: _: perf: subj{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)}
zarosnąć: _: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zarosnąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarosnąć się: _: perf: subj{np(str)} + {np(dat)}
zarysować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zarysowywać: _: imperf: 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)}
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)}
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)}
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ą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)}
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)}
zarządzić: _: perf: subj{np(str)} + obj{np(str)}
zarządzić: _: perf: subj{np(str)} + {or}
zarzucać: _: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
zarzucać: _: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zarzucać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zarzucać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zarzucać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarzucać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
zarzucić: _: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
zarzucić: _: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zarzucić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zarzucić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zarzucić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarzucić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
zarzynać: _: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zarzynać: _: imperf: 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)}
zarżnąć: _: perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zarżnąć: _: perf: 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)}
zasiadać: _: imperf: subj{np(str)} + {prepnp(do,gen)}
zasiadać: _: imperf: subj{np(str)} + {prepnp(w,loc)}
zasiadać: _: 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)}
zasiedlić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
zaskarżyć: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zaskarżyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
zaskarżyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
zasklepiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasklepiać się: _: imperf: subj{np(str)} + {np(inst)}
zasklepiać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
zasklepić: _: perf: 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)}
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ługiwać: _: imperf: subj{np(str)} + {cp(żeby)}
zasługiwać: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zasługiwać się: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
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}
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)}
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}
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)}
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)}
zaspać się: _: perf: subj{np(str)} + {prepnp(na,acc)}
zaspokajać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaspokajać się: _: imperf: subj{np(str)} + {np(inst)}
zaspokoić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaspokoić się: _: perf: subj{np(str)} + {np(inst)}
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)}
zastać się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
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)}
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)}
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)}
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)}
zastawać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
zastąpić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zastąpić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastąpić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastępować: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zastępować: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastępować: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastosować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zastosować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastosować się: _: perf: subj{np(str)} + {prepnp(do,gen)}
zastrzec: _: perf: subj{np(str)} + {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)} + {prepnp(dla,gen)}
zastrzec się: _: perf: subj{np(str)} + {cp(że)}
zastrzec się: _: perf: subj{np(str)} + {or}
zastrzec się: _: perf: subj{np(str)} + {prepnp(przeciw,dat)}
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}
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)}
zasugerować się: _: perf: subj{np(str)} + {cp(że)}
zasugerować się: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)}
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)}
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ć: _: 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)}
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)}
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)}
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)}
zaszczycić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaszkodzić: _: perf: subj,controllee{infp(_)} + controller{np(dat)}
zaszkodzić: _: perf: subj{cp(gdy)} + {np(dat)}
zaszkodzić: _: perf: subj{cp(jak)} + {np(dat)}
zaszkodzić: _: perf: subj{cp(jeśli)} + {np(dat)}
zaszkodzić: _: perf: subj{cp(kiedy)} + {np(dat)}
zaszkodzić: _: perf: subj{cp(że)} + {np(dat)}
zaszkodzić: _: perf: subj{np(str); ncp(str,że)} + {np(dat)}
zaszkodzić: _: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zaszkodzić: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zaszkodzić: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
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)}
zaszyć się: _: perf: subj{np(str)} + {prepnp(w,acc)}
zaszyć się: _: perf: subj{np(str)} + {xp(locat)}
zaścielić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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ś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ś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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zataczać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zataczać: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zataczać się: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zatelefonować: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
zatelefonować: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
zatelefonować: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
zatelefonować: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
zatelefonować: _: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
zatęsknić: _: 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)}
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)}
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)}
zatoczyć się: _: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zatonąć: _: perf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
zatracać: _: imperf: subj{np(str)} + obj{np(str)}
zatracać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
zatracić: _: perf: subj{np(str)} + obj{np(str)}
zatracić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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ć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatruć się: _: perf: subj{np(str)} + {np(inst)}
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)}
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)}
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)}
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)}
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}
zatrzaskiwać się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatrzaskiwać się: _: imperf: 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}
zatrzasnąć się: _: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zatrzasnąć się: _: perf: subj{np(str)} + {prepnp(za,inst)}
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)}
zatrzeć się: _: perf: subj{np(str); ncp(str,że)} + {np(dat)}
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)}
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)}
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)}
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)}
zatwierdzić: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatwierdzić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatwierdzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zatwierdzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zatytułować: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{or}
zatytułować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaufać: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
zaufać: _: perf: subj{np(str)} + {np(dat)} + {prepncp(w,acc,że)}
zaufać: _: perf: subj{np(str)} + {prepnp(w,loc)}
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{cp(żeby2)}
zawadzić: _: perf: subj{infp(_)}
zawadzić: _: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zawahać się: _: perf: subj,controller{np(str)} + controllee{infp(_)}
zawahać się: _: perf: subj{np(str)} + {cp(int)}
zawahać się: _: perf: subj{np(str)} + {cp(żeby)}
zawahać się: _: perf: subj{np(str)} + {cp(żeby2)}
zawahać się: _: perf: subj{np(str)} + {prepncp(nad,inst,żeby)}
zawahać się: _: perf: subj{np(str)} + {prepncp(przed,inst,żeby2)}
zawahać się: _: perf: subj{np(str)} + {prepnp(między,inst)}
zawahać się: _: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zawahać się: _: perf: subj{np(str)} + {prepnp(przed,inst)}
zawalić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zawalić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zawalić się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zawdzięczać: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zawdzięczać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że)}
zawetować: _: perf: subj{np(str)} + obj{np(str)}
zawęzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zawęzić się: _: perf: 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)}
zawężać się: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
zawiązać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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ązać się: _: perf: subj{np(str)} + {prepnp(między,inst)}
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)}
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)}
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}
zawiesić się: _: perf: 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}
zawieszać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
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)}
zawijać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
zawijać się: _: imperf: subj{np(str)} + {xp(abl)}
zawijać się: _: imperf: subj{np(str)} + {xp(adl)}
zawijać się: _: imperf: subj{np(str)} + {xp(locat)}
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}
zawisnąć: _: perf: subj{np(str)} + {prepnp(nad,inst)}
zawisnąć: _: perf: subj{np(str)} + {prepnp(na,loc)}
zawisnąć: _: perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(inst,sg,'wzrok',natr)}
zawisnąć: _: perf: subj{np(str)} + {prepnp(od,gen)}
zawisnąć: _: perf: subj{np(str)} + {prepnp(z,gen)}
zawisnąć: _: perf: subj{np(str)} + {xp(locat)}
zawitać: _: perf: subj{np(str)} + {prepnp(do,gen)}
zawitać: _: perf: subj{np(str)} + {xp(abl)}
zawitać: _: perf: subj{np(str)} + {xp(adl)}
zawitać: _: perf: subj{np(str)} + {xp(locat)}
zawładnąć: _: perf: subj{np(str)} + obj{np(inst)}
zawnioskować: _: perf: subj{np(str)} + obj{np(str)}
zawnioskować: _: perf: subj{np(str)} + {or}
zawnioskować: _: perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zawnioskować: _: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
zawnioskować: _: perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
zawodzić: _: imperf: subj{np(str)} + {np(str)}
zawodzić: _: imperf: subj{np(str)} + obj{np(str)}
zawodzić: _: imperf: subj{np(str)} + {or}
zawodzić się: _: imperf: subj{np(str)} + {prepnp(na,loc)}
zawołać: _: imperf: subj{np(str)} + {np(inst)} + {or}
zawołać: _: imperf: subj{np(str)} + obj{np(str)}
zawołać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zawołać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zawołać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zawołać: _: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
zawołać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zawołać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
zawołać: _: imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
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)}
zawracać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zawracać się: _: imperf: subj{np(str)}
zawrzeć: _: perf: subj{np(str)} + {np(inst)}
zawrzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawrzeć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawrzeć: _: perf: {xp(locat)}
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)}
zazdrościć: _: imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że)}
zaznaczać: _: perf: subj{np(str)} + {cp(int)}
zaznaczać: _: perf: subj{np(str)} + {cp(że)}
zaznaczać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczać: _: perf: subj{np(str)} + {or}
zaznaczać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zaznaczać 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}
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)}
zaznajamiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zaznajamiać się: _: imperf: 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)}
zaznajomić się: _: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
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ż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)}
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)}
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)}
zbankrutować: _: perf: subj{np(str)} + {prepnp(na,loc)}
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)}
zbić się: _: perf: subj{np(str)} + {prepnp(w,acc)}
zbiec: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zbiec: _: perf: subj{np(str)} + {prepnp(z,gen)}
zbiec: _: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zbiec się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'czas',natr)}
zbiec się: _: perf: subj{np(str)} + {xp(adl)}
zbiec się: _: perf: subj{np(str)} + {xp(locat)}
zbiegać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zbiegać: _: imperf: subj{np(str)} + {prepnp(z,gen)}
zbiegać: _: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zbiegać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'czas',natr)}
zbiegać się: _: imperf: subj{np(str)} + {xp(adl)}
zbiegać się: _: imperf: subj{np(str)} + {xp(locat)}
zbierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zbierać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {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)}
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(u,gen)}
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)}
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)}
zbijać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
zbijać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
zbliżać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zbliżać się: _: imperf: subj{np(str)} + {prepnp(do,gen)}
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)}
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}
zbroić: _: perf: subj{np(str)} + {nonch}
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)}
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)}
zburzyć się: _: perf: subj{np(str)} + {np(dat)}
zburzyć się: _: perf: subj{np(str)} + {prepnp(w,loc)}
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ć 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)}
zdarzać: _: imperf: subj{np(str)} + {cp(że)} + {xp(temp)}
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)}
zdarzyć: _: perf: 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)}
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ć 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)}
zdążać: _: imperf: subj,controller{np(str)} + controllee{infp(_)}
zdążać: _: imperf: subj{np(str)} + {cp(żeby)}
zdążać: _: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zdążać: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zdążać: _: imperf: subj{np(str)} + {prepnp(za,inst)}
zdążać: _: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
zdążać: _: imperf: subj{np(str)} + {xp(adl)}
zdążyć: _: perf: subj,controller{np(str)} + controllee{infp(_)}
zdążyć: _: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zdążyć: _: perf: subj{np(str)} + {prepnp(za,inst)}
zdążyć: _: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
zdechnąć: _: perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
zdechnąć: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zdechnąć: _: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',natr)}
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ć: _: 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)}
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)}
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ć: _: 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}
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)}
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}
zdemontować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zdemontować: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zdenerwować: _: perf: subj{cp(gdy)} + {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)}
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,że)}
zdenerwować się: _: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zderzyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zderzyć się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zdjąć: _: perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zdjąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdjąć: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zdobić: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zdobić: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zdobyć: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zdobyć się: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zdobywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zdobywać się: _: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zdołać: _: perf: subj,controller{np(str)} + controllee{infp(_)}
zdominować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
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',natr)}
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)}
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)}
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)}
zdzierać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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)}
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}
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)}
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)}
zechcieć: _: perf: subj,controller{np(str)} + controllee{infp(_)}
zechcieć: _: perf: subj{np(str)} + {np(str)}
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)}
zedrzeć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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)}
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)}
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)}
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,ż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ć: _: 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)}
zepsuć się: _: perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zepsuć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zerkać: _: imperf: subj{np(str)} + {cp(int)}
zerkać: _: imperf: subj{np(str)} + {cp(jak)}
zerkać: _: imperf: subj{np(str)} + {cp(że)}
zerkać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zerkać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zerkać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
zerkać: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zerkać: _: imperf: subj{np(str)} + {prepnp(ku,dat)}
zerkać: _: imperf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int)}
zerkać: _: imperf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
zerknąć: _: perf: subj{np(str)} + {cp(int)}
zerknąć: _: perf: subj{np(str)} + {cp(jak)}
zerknąć: _: perf: subj{np(str)} + {cp(że)}
zerknąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zerknąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zerknąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
zerknąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zerknąć: _: perf: subj{np(str)} + {prepnp(ku,dat)}
zerknąć: _: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int)}
zerknąć: _: perf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
zeskakiwać: _: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zeskoczyć: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zesłać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zesłać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
zesłać: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
zestrzelić się: _: perf: 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)}
zestrzeliwać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
zetknąć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zetknąć się: _: perf: subj{np(str)} + {prepncp(z,inst,int)}
zetknąć się: _: perf: subj{np(str)} + {prepncp(z,inst,że)}
zetknąć się: _: perf: subj{np(str)} + {prepncp(z,inst,żeby2)}
zetknąć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
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)}
zgasnąć: _: perf: subj{np(str)} + {np(dat)}
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ł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)}
zgodzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,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)}
zgolić: _: perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
zgolić: _: perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
zgolić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
zgolić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zgolić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zgotować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zgrać: _: 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)}
zgrać się: _: perf: subj{np(str)} + {prepnp(w,acc)}
zgrać się: _: perf: subj{np(str)} + {prepnp(z,inst)}
zgromadzić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgromadzić się: _: perf: subj{np(str)} + {xp(locat)}
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ć: _: 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)}
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)}
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ć: _: 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)}
zidentyfikować się: _: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zidentyfikować się: _: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
zielenić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zielenić się: _: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zielenić się: _: imperf: subj{np(str)} + {np(inst)}
zielenić się: _: imperf: subj{np(str)} + {prepnp(od,gen)}
zielenić się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
ziewać: _: imperf: subj{np(str)}
ziewnąć: _: perf: subj{np(str)}
zintegrować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zintegrować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zintegrować się: _: perf: subj{np(str)} + {prepnp(wokół,gen)}
zintegrować się: _: perf: subj{np(str)} + {prepnp(z,inst)}
zionąć: _: imperf: {np(inst)} + {xp(locat)}
zionąć: _: imperf: subj{np(dat)} + {np(inst)}
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)}
zipać: _: imperf: subj{np(str)} + {fixed('ledwie')}
zipać: _: imperf: subj{np(str)} + {fixed('ledwo')}
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)}
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)}
ziścić: _: perf: subj{np(str)} + obj{np(str)}
ziścić się: _: perf: subj{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)}
zjechać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); 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)}
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)}
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ć: _: 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)}
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)}
zjednywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zjednywać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(dla,gen)}
zjeść: _: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
zjeść: _: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zjeść: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zjeść: _: perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(str,pl,'ząb',natr)}
zjeżdżać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); 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ż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)}
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)}
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)}
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)}
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)}
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)}
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)}
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)}
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łamać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
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ł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łą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łą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łocić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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ł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ż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ł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)}
zmagać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
zmaleć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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)}
zmarnować się: _: perf: subj{np(str)}
zmarszczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
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)}
zmawiać: _: imperf: subj{np(str)} + obj{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)}
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)}
zmęczyć się: _: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
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)}
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)}
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)}
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)}
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)}
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}
zmierzyć się: _: perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zmieszać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zmieszać się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zmieszać się: _: perf: subj{np(str)} + {np(inst)}
zmieścić: _: perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
zmieścić: _: perf: subj{np(str)} + {np(str)} + {xp(locat)}
zmieścić się: _: perf: subj{np(str)} + {prepnp(w,loc)}
zmieścić się: _: perf: subj{np(str)} + {xp(locat)}
zmięknąć: _: perf: subj{np(str)} + {np(dat)}
zmięknąć: _: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
zmiłować się: _: perf: subj{np(str)} + {prepnp(nad,inst)}
zmniejszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zmniejszać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmniejszyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zmniejszyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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)}
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)}
zmodernizować: _: perf: subj{np(str)} + {np(inst)} + {refl}
zmodernizować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
zmodyfikować się: _: perf: subj{np(str)}
zmoknąć: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
zmoknąć: _: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zmóc: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmóc się: _: perf: subj{np(str)} + {cp(żeby)}
zmóc się: _: perf: subj{np(str)} + {prepnp(na,acc)}
zmówić: _: perf: subj{np(str)} + obj{np(str)}
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)}
zmusić: _: perf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zmusić: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmusić: _: perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zmusić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zmusić: _: perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
zmusić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zmusić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmuszać: _: imperf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zmuszać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmuszać: _: imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zmuszać: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {refl}
zmuszać: _: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)}
zmuszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zmuszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmyś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)}
znaczyć: _: imperf: subj{infp(_)} + {infp(_)}
znaczyć: _: imperf: subj{infp(_)} + {np(str)}
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}
znaczyć się: _: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
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)}
znać się: _: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
znać się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
znajdować się: _: imperf: subj,controller{np(str)} + controllee{adjp(inst)}
znajdować się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
znajdować się: _: imperf: 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)}
znaleźć się: _: perf: subj,controller{np(str)} + controllee{adjp(inst)}
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)}
znamionować: _: imperf: subj{np(str)} + {cp(że)}
znamionować: _: imperf: subj{np(str); ncp(str,że)} + {np(str); ncp(str,że)}
znarowić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
znarowić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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)}
znęcać się: _: imperf: subj{np(str)} + {prepnp(nad,inst)}
zniechęcać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcać się: _: imperf: 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)} + 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)}
zniecierpliwić: _: perf: subj{cp(że)} + {np(str)}
zniecierpliwić: _: perf: subj{np(str); ncp(str,że)} + {np(str)}
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)}
zniekształcać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zniekształcać się: _: imperf: subj{np(str)} + {np(dat)}
zniekształcić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zniekształcić się: _: perf: subj{np(str)} + {np(dat)}
znienawidzić: _: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
znienawidzić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
znienawidzić: _: perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
zniesławiać: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zniesławiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zniesławić: _: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
zniesławić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
znieść: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(jak)}
znieść: _: perf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(że)}
znieść: _: perf: subj,controller{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + controllee{xp(mod)}
znieść: _: perf: subj{np(str)} + {cp(gdy)}
znieść: _: perf: subj{np(str)} + {cp(jak)}
znieść: _: perf: subj{np(str)} + {cp(kiedy)}
znieść: _: perf: subj{np(str)} + {cp(że)}
znieść: _: perf: subj{np(str)} + {np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
znieść: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
znieść: _: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
znieść: _: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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ć: _: perf: subj{np(str)} + {np(inst)} + {refl}
zniszczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zniszczyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zniweczyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
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)}
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)}
znosić: _: perf: subj{np(str)} + obj{np(str)}
znosić się: _: imperf: subj{np(str)} + {prepnp(z,inst)}
znowelizować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
znudzić: _: perf: subj{np(str); ncp(str,że)} + {np(str)}
znudzić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)}
zobaczyć: _: perf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)}
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)} + {np(inst)}
zobaczyć się: _: perf: subj,controller{np(str)} + controllee{adjp(inst)}
zobaczyć się: _: perf: subj{np(str)} + {prepnp(z,inst)}
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)} + {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)} + {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)}
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(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
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)}
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)}
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)}
zostawiać: _: imperf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)} + {xp(locat)}
zostawiać: _: imperf: subj{np(str)} + {np(inst)} + {np(str)}
zostawiać: _: imperf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',natr)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zostawiać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
zostawić: _: perf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)} + {xp(locat)}
zostawić: _: perf: subj{np(str)} + {np(inst)} + {np(str)}
zostawić: _: perf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',natr)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zostawić: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
zrabować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zrabować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zranić: _: 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)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,acc)}
zranić: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zranić się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zranić się: _: perf: subj{np(str)} + {prepnp(o,acc)} + {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ć: _: imperf: subj{np(str)} + {np(inst)} + {refl}
zraszać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zraszać się: _: imperf: subj{np(str)} + {np(inst)}
zrazić: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrazić: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)}
zrazić się: _: perf: 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)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {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ć się: _: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrealizować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zrealizować się: _: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zrealizować się: _: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zreformować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zreformować się: _: perf: subj{np(str)}
zrekonstruować: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrekonstruować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
zremisować: _: perf: subj{np(str)} + obj{np(str)}
zremisować: _: perf: subj{np(str)} + {prepnp(z,inst)}
zretuszować: _: perf: subj{np(str)} + obj{np(str)}
zrezygnować: _: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
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)}
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)}
zrosić: _: perf: subj{np(str)} + {np(inst)} + {refl}
zrosić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zrosić się: _: perf: subj{np(str)} + {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)}
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)}
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ć: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zrzeszać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zrzeszać się: _: imperf: subj{np(str)} + {prepnp(w,acc)}
zrzeszać się: _: imperf: subj{np(str)} + {prepnp(w,loc)}
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)} + {prepnp(z,gen)}
zrzucać: _: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zrzucać się: _: imperf: subj{np(str)} + {prepnp(na,acc)}
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)} + {prepnp(z,gen)}
zrzucić: _: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zrzucić się: _: perf: subj{np(str)} + {prepnp(na,acc)}
zsunąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zsunąć się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsuwać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zsuwać się: _: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
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)}
zutylizować: _: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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żyć się: _: perf: subj{np(str)} + {prepnp(na,loc)}
zużyć się: _: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zużywać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zużywać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zużywać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zużywać się: _: perf: subj{np(str)} + {prepnp(na,loc)}
zużywać się: _: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
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)}
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)}
zwalczać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
zwariować: _: perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
zwariować: _: perf: subj{np(str)} + {prepnp(dla,gen)}
zwariować: _: perf: subj{np(str)} + {prepnp(od,gen)}
zwariować: _: perf: subj{np(str)} + {prepnp(z,gen)}
zważ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}
zweryfikować: _: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
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)} + {xp(locat)}
zwęglić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwęglić się: _: perf: subj{np(str)} + {np(dat)}
zwęzić: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
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ężać: _: imperf: 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)}
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ć: _: 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)} + {prepnp(w,acc)}
związać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
związać się: _: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zwiedzać: _: imperf: subj{np(str)} + obj{np(str)}
zwiedzić: _: perf: subj{np(str)} + obj{np(str)}
zwierzać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
zwierzyć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
zwieść: _: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zwieść: _: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zwieść: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
zwiększać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwiększać się: _: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwiększyć: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwiększyć się: _: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwijać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,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)}
zwinąć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
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)}
zwindować: _: perf: subj{np(str)} + obj{np(str)}
zwisać: _: imperf: subj{cp(int)} + {np(dat)} + {np(inst)}
zwisać: _: imperf: subj{cp(że)} + {np(dat)} + {np(inst)}
zwisać: _: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zwisać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zwisać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zwisać: _: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zwlekać: _: 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)}
zwlekać się: _: imperf: subj{np(str)} + {prepnp(z,gen)}
zwlekać się: _: imperf: subj{np(str)} + {xp(abl)}
zwodować: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zwodować: _: perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
zwodzić: _: imperf: subj{np(str)} + {cp(że)} + {refl}
zwodzić: _: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
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)} + {prepnp(z,gen)} + {xp(adl)}
zwodzić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
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)}
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)}
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(ku,dat)}
zwracać się: _: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
zwrócić: _: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'uwaga',atr)}
zwrócić: _: 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)}
zwrócić: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwrócić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zwrócić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zwrócić: _: 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(ku,dat)}
zwrócić się: _: perf: subj{np(str)} + {prepnp(przeciw,dat)}
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)}
zwyknąć: _: perf: subj,controller{np(str)} + controllee{infp(_)}
zwyknąć: _: perf: subj{np(str)} + {cp(żeby)}
zyskać: _: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zyskać: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zyskać: _: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zyskać: _: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zyskiwać: _: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zyskiwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zyskiwać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zyskiwać: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zziajać się: _: perf: subj{np(str)} + {np(inst)}
zziajać się: _: perf: subj{np(str)} + {prepnp(od,gen)}
zzuć: _: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zzuć się: _: perf: subj{np(str)} + {prepnp(z,gen)}
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,że)}
zżymać się: _: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
ż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ł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)}
żartować: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
żartować: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
żartować: _: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
żartować: _: imperf: subj{np(str)} + {prepnp(z,inst)}
żąć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
żądać: _: imperf: subj{np(str)} + {np(gen); cp(żeby); ncp(gen,żeby)} + {prepnp(od,gen)}
żądać: _: imperf: subj{np(str)} + {or}
ż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)}
żegnać: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
żegnać się: _: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
żenić: _: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
żenić się: _: imperf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
żenić się: _: imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
żerować: _: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
żerować: _: imperf: subj{np(str)} + {xp(locat)}
żółcić: _: imperf: subj{np(str)} + obj{np(str)}
żółcić się: _: imperf: subj{np(str)} + {np(inst)}
żółcić się: _: imperf: subj{np(str)} + {xp(locat)}
żuć: _: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ż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(za,acc)} + {lexnp(dat,_,'siebie',natr)}
życzyć: _: imperf: subj{np(str)} + {np(str)} + {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)}
ż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)}
żywić się: _: imperf: subj,controller{np(str)} + controllee{xp(mod)}
żywić się: _: imperf: subj{np(str)} + {np(inst)}
