
% The Polish Valence Dictionary (Walenty)
% January 23, 2013
%
% 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 milion sample of
% NKJP (National Corpus of Polish).
%
% The presented version uses an updated, more specific format
% in comparison with the original, and expands both the
% number of frames for the original entries and the number
% of entries.
%
% The format of the new dictionary has been established by Filip
% Skwarski, Elżbieta Hajnicz, Witold Kieraś, Agnieszka Patejuk,
% Adam Przepiórkowski, Marek Świdziński, and Marcin Woliński.
%
% Manual edition of the presented dictionary entries has been
% carried out by Filip Skwarski, Sebastian Żurowski, Jakub
% Szymczak, Piotr Batko, Joanna Filipczak, Marta Kalużna, Marcin
% Opacki, Paulina Rosalska and Maciej Zgondek.
%
% The dictionary has been edited and compiled using Slowal,
% 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,2013 by Marek Świdziński
%
% This work is distributed under a CC BY-SA license:
% http://creativecommons.org/licenses/by-sa/2.0/
%
adresować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,acc)}
adresować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
akceptować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
analizować: imperf: subj{np(str)} + {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)}
apelować: imperf: subj{np(str)} + {or}
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)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
aresztować: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
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)}
bać się: imperf: subj,controller{np(str)} + controlee{infp(_)}
bać się: imperf: subj,controller{np(str)} + {prepnp(o,acc)} + {cp(żeby)}
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); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
badać: imperf: subj{np(str)} + {np(inst)} + {cp(int)}
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)} + {or}
badać się: imperf: subj{np(str)} + {prepnp(u,gen)}
badać się: imperf: subj{np(str)} + {xp(locat)}
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)} + {prepnp(u,gen)}
bawić się: imperf: subj{np(str)} + {cp(że)}
bawić się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
bawić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
bawić się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
bawić się: imperf: subj{np(str)} + {xp(locat)}
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)} + controlee{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)}
biec: imperf: subj{np(str)} + {xp(perl)}
biegać: imperf: {np(dat)} + {prepncp(o,acc,int)}
biegać: imperf: {np(dat)} + {prepncp(o,acc,że)}
biegać: imperf: {np(dat)} + {prepnp(o,acc)}
biegać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
biegać: imperf: subj{np(str)} + {prepnp(za,inst)}
biegać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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łyszczeć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
błyszczeć się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
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)}
boleć: imperf: subj{np(str)} + {xp(locat)}
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)} + controlee{prepadjp(za,acc)}
brać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + {prepncp(od,gen,że)}
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)}
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)}
brak: imperf: {np(gen)} + {xp(locat)}
brakować: imperf: {np(dat)} + {cp(żeby)}
brakować: imperf: {np(dat)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
bronić: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)}
bronić: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
bronić: imperf: subj{np(str)} + {np(gen)} + {prepnp(przed,inst)}
bronić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
bronić się: imperf: subj{np(str)} + {cp(że)}
bronić się: imperf: subj{np(str)} + {np(inst)}
bronić się: imperf: subj{np(str)} + {or}
bronić się: imperf: subj{np(str)} + {prepnp(od,gen)}
bronić się: imperf: subj{np(str)} + {prepnp(przed,inst)}
brzmieć: imperf: subj,controller{np(str)} + controlee{np(nom)}
brzmieć: imperf: subj,controller{np(str)} + controlee{xp(mod)}
brzmieć: imperf: subj{np(str)} + {prepnp(w,loc)}
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)} + {np(inst)} + {prepnp(w,loc)}
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śród,gen)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
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)} + {prepncp(o,acc,że)}
burzyć się: imperf: subj{np(str)} + {prepnp(o,acc)}
burzyć się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
burzyć się: imperf: subj{np(str)} + {prepnp(w,loc)}
być: imperf: {np(dat)} + {cp(że)} + {xp(mod)}
być: imperf: {np(dat)} + {infp(_)} + {advp(misc)}
być: imperf: {prepnp(z,inst)} + {advp(misc)}
być: imperf: subj,controller{cp(gdy)} + controlee{adjp(pred)}
być: imperf: subj,controller{cp(gdy)} + controlee{np(inst)}
być: imperf: subj,controller{cp(int)} + controlee{adjp(pred)}
być: imperf: subj,controller{cp(int)} + controlee{np(inst)}
być: imperf: subj,controller{cp(jak)} + controlee{adjp(pred)}
być: imperf: subj,controller{cp(jak)} + controlee{np(inst)}
być: imperf: subj,controller{cp(jakoby)} + controlee{np(inst)}
być: imperf: subj,controller{cp(jeśli)} + controlee{adjp(pred)}
być: imperf: subj,controller{cp(jeśli)} + controlee{np(inst)}
być: imperf: subj,controller{cp(kiedy)} + controlee{adjp(pred)}
być: imperf: subj,controller{cp(kiedy)} + controlee{np(inst)}
być: imperf: subj,controller{cp(żeby)} + controlee{adjp(pred)}
być: imperf: subj,controller{cp(żeby)} + controlee{np(inst)}
być: imperf: subj,controller{cp(że)} + controlee{adjp(pred)}
być: imperf: subj,controller{cp(że)} + controlee{np(inst)}
być: imperf: subj,controller{infp(_)} + controlee{adjp(pred)}
być: imperf: subj,controller{infp(_)} + controlee{np(inst)}
być: imperf: subj,controller{np(str)} + controlee{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)} + controlee{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)} + controlee{np(inst)}
być: imperf: subj{np(str)} + {lexnp(gen,sg,'zdanie',ratr)}
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(u,gen); xp(locat)}
być: imperf: subj{np(str)} + {prepnp(w,loc)}
być: imperf: subj{np(str)} + {prepnp(z,inst)}
być: imperf: subj{np(str)} + {xp(temp)}
bywać: imperf: {np(dat)} + {advp(misc)}
bywać: imperf: {prepnp(z,inst)} + {advp(misc)}
bywać: imperf: subj,controller{cp(że)} + controlee{np(inst)}
bywać: imperf: subj,controller{np(str)} + controlee{adjp(pred)}
bywać: imperf: subj,controller{np(str)} + controlee{np(inst)}
bywać: imperf: subj{cp(że)}
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)} + {prepnp(z,gen)}
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)} + {preplexnp(z,gen,sg,'dubeltówka',natr)}
całować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepnp(w,acc)}
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)}
celować: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
celować: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
celować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
celować: imperf: subj{np(str)} + {prepnp(ku,dat)}
celować: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
celować: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
celować: imperf: subj{np(str)} + {prepnp(w,loc)}
celować: imperf: subj{np(str)} + {xp(locat)}
cenić: imperf: subj{np(str)} + {advp(misc)} + {refl}
cenić: imperf: subj{np(str)} + {np(dat)} + {cp(że); ncp(str,że)} + {xp(locat)}
cenić: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
charakteryzować: imperf: subj,controller{np(str)} + controlee{prepadjp(na,acc)} + {refl}
charakteryzować: imperf: subj,controller{np(str)} + controlee{prepnp(na,acc)} + {refl}
charakteryzować: imperf: subj{np(str); ncp(str,że)} + {np(str)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(na,acc)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(na,acc)}
charakteryzować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
chcieć: imperf: controller{np(str)} + controlee{cp(żeby); infp(_); advp(misc)}
chcieć: imperf: subj,controller{np(str)} + controlee{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(locat)}
chcieć się: imperf: controller{np(dat)} + controlee{infp(_)}
chcieć się: imperf: {np(dat)} + {np(gen)}
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)} + controlee{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)} + {prepncp(za,inst,żeby)}
chodzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
chodzić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {xp(abl)}
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)}
chodzić: imperf: subj{np(str)} + {prepnp(w,loc)}
chodzić: imperf: subj{np(str)} + {prepnp(za,inst)}
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)}
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)} + {xp(abl)}
chować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {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ć się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
chować się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
chrapać: imperf: subj{np(str)}
chronić: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
chronić: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)} + {refl}
chronić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
chronić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
chronić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
chronić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
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)}
chwalić: imperf: subj{np(str)} + {np(str); ncp(str,że)}
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)} + {prepnp(za,acc)} + {or}
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)} + {or}
ciąć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
ciąć: imperf: 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: subj{np(str)} + {np(str)} + {or}
ciągnąć: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
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)}
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)}
cierpieć: imperf: subj,controller{np(str)} + controlee{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)}
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)}
cytować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)} + {or}
cytować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)}
czcić: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
czcić: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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,ż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)} + {xp(dur)} + {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)}
czesać: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {np(inst)} + {refl}
czesać: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)} + {np(dat)} + {np(inst)}
czesać się: imperf: subj,controller{np(str)} + controlee{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(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ć się: imperf: subj,controller{np(str)} + controlee{adjp(pred)}
czuć się: imperf: subj,controller{np(str)} + controlee{infp(_)} + {preplexnp(na,loc,_,'siła',natr)}
czuć się: imperf: subj,controller{np(str)} + controlee{infp(_)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
czuć się: imperf: subj,controller{np(str)} + controlee{np(inst)}
czuć się: imperf: subj,controller{np(str)} + controlee{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)}
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)}
czynić: imperf: subj,controller{np(str)} + controlee{xp(mod)}
czynić: imperf: subj{np(str)} + controller{np(str)} + controlee{adjp(inst)}
czynić: imperf: subj{np(str)} + controller{np(str)} + controlee{np(inst)}
czynić: imperf: subj{np(str)} + obj{lexnp(str,sg,'wrażenie',atr)} + {prepnp(na,loc)}
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)} + controlee{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,że)}
czytać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
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(w,loc)}
czytać: imperf: subj{np(str)} + {prepnp(z,gen)}
ć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(w,loc)}
ćwiczyć się: imperf: subj{np(str)} + {prepncp(w,loc,żeby)}
ćwiczyć się: imperf: subj{np(str)} + {prepnp(w,loc)}
dać: perf: {infp(_)} + {lexnp(str,sg,'rada',natr)}
dać: perf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'rada',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'czas',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'możliwość',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'okazja',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'prawo',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,_,'szansa',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{np(nom)} + {preplexnp(na,str,sg,'imię',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controlee{xp(mod)} + {preplexnp(na,str,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)}
dawać: imperf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'rada',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'czas',atr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'możliwość',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'okazja',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'prawo',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)} + {lexnp(str,_,'szansa',atr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{np(nom)} + {preplexnp(na,str,sg,'imię',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controlee{xp(mod)} + {preplexnp(na,str,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)}
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)} + controlee{infp(_)}
decydować się: imperf: subj{np(str)} + {cp(int)}
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)}
deklarować: imperf: subj{np(str)} + obj{np(str); cp(że)} + {np(dat)}
deklarować: imperf: subj{np(str)} + {or}
deklarować się: imperf: subj,controller{np(str)} + controlee{infp(_)}
deklarować się: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
deklarować się: imperf: subj{np(str)} + {cp(że)}
deklarować się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
deklarować się: imperf: subj{np(str)} + {preplexnp(po,loc,sg,'strona',natr)}
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)}
deklarować się: imperf: subj{np(str)} + {prepnp(za,inst)}
dekorować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
denerwować: imperf: subj{cp(gdy)} + {np(str)}
denerwować: imperf: subj{cp(jak)} + {np(str)}
denerwować: imperf: subj{cp(kiedy)} + {np(str)}
denerwować: imperf: subj{cp(że)} + {np(str)}
denerwować: imperf: subj{np(str); ncp(str,int); 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)}
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)}
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)}
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)} + {or}
dobiec: perf: subj{np(str)} + {np(str)} + {xp(abl)} + {or}
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)} + {or}
dobiec: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)} + {or}
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)} + {or}
dobiegać: imperf: subj{np(str)} + {np(str)} + {xp(abl)} + {or}
dobiegać: imperf: subj{np(str); or} + {np(gen)} + {xp(abl)}
dobiegać: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {or}
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)}
doceniać: imperf: subj{np(str)} + {cp(int)}
doceniać: imperf: subj{np(str)} + {cp(że)}
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)} + {refl}
docenić: imperf: subj{np(str)} + {cp(int)}
docenić: imperf: subj{np(str)} + {cp(że)}
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)} + {refl}
dochodzić: imperf: {prepnp(do,gen); prepncp(do,gen,że)}
dochodzić: imperf: subj{cp(że); ncp(str,że)} + {prepnp(do,gen)}
dochodzić: imperf: subj{np(str)} + {cp(int); ncp(gen,int)}
dochodzić: imperf: subj{np(str)} + {cp(że); ncp(gen,że)}
dochodzić: imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
dochodzić: imperf: subj{np(str)} + {prepncp(do,gen,int)}
dochodzić: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
dochodzić: imperf: subj{np(str)} + {xp(adl)}
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)}
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(z,inst)} + {comprepnp(co do); comprepnp(w kwestii); 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)}
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)} + {prepnp(na,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)}
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)}
dokuczać: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
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)}
dokuczać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
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)} + {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)}
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(int)}
domyślać się: imperf: subj{np(str)} + {cp(że)}
domyślać się: imperf: subj{np(str)} + {np(gen); ncp(gen,że)}
donosić: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
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,że)}
donosić: imperf: subj{np(str)} + {np(part)}
donosić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
donosić: perf: subj{np(str)} + {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)} + controlee{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)} + controlee{prepadjp(jako,str)}
dookreślić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
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)}
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)}
doradzić: perf: subj{np(str)} + controller{np(dat)} + controlee{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)} + {np(dat)}
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)}
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)}
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)}
dostać: perf: subj,controller{np(str)} + controlee{infp(_)}
dostać: perf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'nakaz',natr)}
dostać: perf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'polecenie',natr)}
dostać: perf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dostać: perf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'szansa',natr)}
dostać: perf: subj,controller{np(str)} + controlee{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ć: perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(po,acc)}
dostać: perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(po,loc); prepnp(w,acc)}
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)} + controlee{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(po,acc)}
dostawać: imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(po,loc); prepnp(w,acc)}
dostawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostawać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dostosować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dostosować się: perf: subj{np(str)} + {prepnp(do,gen)}
dostrajać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dostrajać się: imperf: subj{np(str)} + {prepnp(do,gen)}
dostroić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dostroić się: perf: subj{np(str)} + {prepnp(do,gen)}
dostrzec: perf: subj{np(str)} + {cp(jak)}
dostrzec: perf: subj{np(str)} + {cp(żeby2)}
dostrzec: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzec: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dostrzegać: imperf: subj{np(str)} + {cp(jak)}
dostrzegać: imperf: subj{np(str)} + {cp(żeby2)}
dostrzegać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
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)}
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)}
dotrzymywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
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)}
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)}
doznać: perf: subj{np(str)} + obj{np(gen)}
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ę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)}
drożeć: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
drożeć: imperf: subj{np(str)} + {prepnp(o,acc)}
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(w,loc)}
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)} + {prepncp(przed,inst,żeby)}
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)}
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)}
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); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
dyskutować: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
dyskutować: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
dyskutować: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(nad,inst,żeby)}
dysponować: imperf: subj{np(str)} + {np(inst)}
dysponować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dysponować: imperf: subj{np(str)} + {or}
dziać się: imperf: {np(dat)} + {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)}
działać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{xp(mod)} + {np(inst)}
działać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
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)}
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)}
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)} + {cp(int)}
dziwić się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dziwić się: imperf: subj{np(str)} + {np(dat); cp(że); ncp(dat,int); ncp(dat,że)}
dziwić się: imperf: subj{np(str)} + {or}
dzwonić: imperf: subj{np(str)} + {comprepnp(w sprawie)}
dzwonić: imperf: subj{np(str)} + {np(dat)}
dzwonić: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',natr)}
dzwonić: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',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)} + {cp(int); cp(że)}
dzwonić: imperf: subj{np(str)} + {prepnp(na,acc)}
dzwonić: imperf: subj{np(str)} + {prepnp(po,acc)}
dzwonić: imperf: subj{np(str)} + {prepnp(za,inst)}
dzwonić: imperf: subj{np(str)} + {xp(adl)}
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)}
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ę: perf: subj{np(str)} + {advp(misc)}
farbować się: perf: subj{np(str)} + {np(inst)}
farbować się: perf: subj{np(str)} + {prepnp(na,acc)}
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)} + controlee{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)}
finansować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
finansować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
flirtować: imperf: subj{np(str)} + {prepnp(z,inst)}
formułować: imperf: subj{np(str)} + controller{ncp(str,że)} + controlee{prepnp(jako,str)}
formułować: imperf: subj{np(str)} + {ncp(str,int)}
formułować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
formułować: imperf: subj{np(str)} + obj{np(str)}
formułować: imperf: subj{np(str)} + obj{np(str)} + {or}
fruwać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
fruwać: imperf: subj{np(str)} + {prepnp(na,loc)}
funkcjonować: imperf: subj,controller{np(str)} + controlee{prepadjp(jako,str)}
funkcjonować: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
funkcjonować: imperf: subj,controller{np(str)} + controlee{xp(mod)}
gadać: imperf: subj,controller{np(str)} + controlee{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(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)}
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)}
gasić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gasić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
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)} + {prepnp(pod,inst)}
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ł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ł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)} + obj{np(str)}
głosować: imperf: subj{np(str)} + {or}
głosować: imperf: subj{np(str)} + {prepncp(nad,inst,żeby)}
głosować: imperf: subj{np(str)} + {prepnp(na,acc)}
głosować: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
głosować: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(za,inst,żeby)}
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)} + {prepnp(od,gen)}
gnić: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
gnić: imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'wpływ',ratr)}
gnić: imperf: subj{np(str)} + {prepnp(w,loc)}
gnić: imperf: subj{np(str)} + {xp(locat)}
gnieść: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{prepnp(jak,str)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)} + {prepnp(w,loc)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
gnieść się: imperf: subj,controller{np(str)} + controlee{prepnp(jak,str)}
gnieść się: imperf: subj{np(str)}
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)}
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: subj,controlee{infp(_)} + controller{np(dat)}
godzić się: imperf: subj,controller{np(str)} + controlee{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)} + {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)} + controlee{xp(mod)} + {np(dat)}
goić się: imperf: subj{np(str)} + controller{prepnp(na,loc)} + controlee{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(inst)} + {xp(locat)}
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)}
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)} + {cp(żeby)}
gotować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
gotować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
gotować: imperf: subj{np(str)} + {xp(locat)}
gotować się: imperf: subj{np(str)} + {comprepnp(z powodu)}
gotować się: imperf: subj{np(str)} + {cp(żeby)}
gotować się: imperf: subj{np(str)} + {prepnp(do,gen)}
gotować się: imperf: subj{np(str)} + {prepnp(na,acc)}
gotować się: imperf: subj{np(str)} + {prepnp(od,gen)}
gotować się: imperf: subj{np(str)} + {prepnp(w,loc)}
gotować się: imperf: subj{np(str)} + {xp(locat)}
grać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
grać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
grać: imperf: subj{np(str)} + {np(inst)}
grać: imperf: subj{np(str)} + obj{np(str)}
grać: imperf: subj{np(str)} + {prepncp(na,acc,że)}
grać: imperf: subj{np(str)} + {prepncp(o,acc,żeby)}
grać: imperf: subj{np(str)} + {prepnp(do,gen)}
grać: imperf: subj{np(str)} + {prepnp(na,acc)}
grać: imperf: subj{np(str)} + {prepnp(o,acc)}
grać: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
grać: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
graniczyć: imperf: subj{np(str)} + {prepnp(z,inst)}
gratulować: imperf: subj{np(str)} + {np(dat)} + {np(gen); cp(że); ncp(gen,że)}
gromadzić: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gromadzić się: imperf: subj{np(str)} + {xp(locat)}
grozić: imperf: subj{np(str)} + {np(dat)} + {np(inst); cp(że); ncp(inst,że)} + {or}
grozić: imperf: subj{np(str)} + {np(dat)} + {prepncp(za,acc,że)}
grozić: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
gryźć: imperf: subj{cp(że)} + {np(str)}
gryźć: imperf: subj{ncp(str,że)} + {np(str)}
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)} + {refl}
gryźć się: imperf: subj{np(str)} + {cp(int)}
gryźć się: imperf: subj{np(str)} + {cp(że)}
gryźć się: imperf: subj{np(str)} + {ncp(inst,że)}
gryźć się: imperf: subj{np(str)} + {np(inst)}
gryźć się: imperf: subj{np(str)} + {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)}
grzmieć: imperf: subj{E}
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(przeciw,dat)}
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)} + {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)}
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)} + {prepncp(na,acc,int)}
gwizdać: imperf: subj{np(str)} + {prepnp(na,acc)}
hamować: imperf: subj{np(str)} + {cp(żeby)} + {refl}
hamować: imperf: subj{np(str)} + {np(str)} + {or}
hamować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
hamować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
hamować się: imperf: subj{np(str)} + {or}
handlować: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
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)}
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)}
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)}
inkasować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
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)} + {prepnp(przez,acc)}
interweniować: imperf: subj{np(str)} + {prepnp(przy,inst)}
interweniować: imperf: subj{np(str)} + {prepnp(u,gen); prepnp(w,loc)}
interweniować: imperf: subj{np(str)} + {prepnp(w,acc)}
inwestować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
istnieć: imperf: subj{np(str)} + {prepnp(dla,gen)}
istnieć: imperf: subj{np(str)} + {xp(dur)}
istnieć: imperf: subj{np(str)} + {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)} + controlee{infp(_)} + {xp(adl)}
iść: imperf: subj,controller{np(str)} + controlee{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(do,gen); xp(adl)} + {prepnp(od,gen)}
iść: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {xp(abl)}
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(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}
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')}
jeść: imperf: subj,controller{np(str)} + controlee{xp(mod)}
jeść: imperf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,sg,'ręka',natr)}
jeść: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
jeść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
jeść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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ć się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kaleczyć się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
kandydować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
kandydować: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
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)}
kazać: _: subj{ncp(str,że)} + controller{np(dat)} + controlee{infp(_)}
kazać: _: subj{np(str)} + controller{np(dat)} + controlee{cp(żeby); infp(_)}
kazać: _: subj{np(str)} + {np(dat)} + {or}
kąpać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kąpać się: imperf: subj{np(str)} + {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)}
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)}
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)}
kląć: imperf: subj,controller{np(str)} + controlee{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)}
klęczeć: imperf: subj{np(str)} + {prepnp(przed,inst)}
klęczeć: imperf: subj{np(str)} + {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)}
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)} + controlee{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)} + controlee{infp(ndk)}
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,sg,'głowa',natr)} + {cp(że)} + {preplexnp(pod,acc,sg,'topór',natr)}
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)} + {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ść: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
kłaść: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
kłaść się: imperf: subj,controller{np(str)} + controlee{infp(ndk)}
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łócić się: imperf: subj{np(str)} + {np(str)}
kłócić się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(o,acc,ż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)}
kochać: imperf: subj,controller{np(str)} + controlee{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)}
kojarzyć: imperf: subj{np(str)} + {cp(int); cp(że)}
kojarzyć: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
kojarzyć: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
kojarzyć: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); 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(w,loc)} + {prepnp(z,inst); prepncp(z,inst,że)}
kojarzyć się: imperf: subj,controller{np(str)} + controlee{prepadjp(jako,str)} + {np(dat)}
kojarzyć się: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {np(dat)}
kojarzyć się: imperf: subj{cp(jak)} + {np(dat)} + {advp(misc)}
kojarzyć się: imperf: subj{cp(że)} + {np(dat)}
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(u,gen)} + {advp(misc)}
kojarzyć się: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)}
kojarzyć się: imperf: subj{np(str)} + {prepnp(w,acc)}
kojarzyć się: imperf: subj{np(str)} + {prepnp(w,loc)} + {advp(misc)}
kojarzyć się: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,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)}
komentować: imperf: subj{np(str)} + obj{np(str)} + {or}
komplikować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
komplikować się: imperf: subj{np(str)}
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)}
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)}
kontrolować: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
kontrolować: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)} + {np(inst)}
kontrolować: imperf: subj{np(str)} + {refl}
kontynuować: imperf: subj{np(str)} + obj{np(str)} + {or}
kończyć: imperf: subj,controller{np(str)} + controlee{infp(ndk)}
kończyć: imperf: subj,controller{np(str)} + controlee{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)} + {or}
kończyć: imperf: subj{np(str)} + {prepncp(na,loc,że)}
kończyć: imperf: subj{np(str)} + {prepnp(na,loc)}
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)} + controlee{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)}
kopać: imperf: subj{np(str)} + {np(inst)} + {refl}
kopać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
kopać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kopać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepnp(w,acc)}
kopać się: imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)}
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)}
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)}
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)}
kreować: imperf: subj,controller{np(str)} + controlee{prepadjp(na,acc)} + {refl}
kreować: imperf: subj,controller{np(str)} + controlee{prepnp(na,acc)} + {refl}
kreować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(na,acc)}
kreować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(na,acc)}
kreować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
kroić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kroić: imperf: subj{np(str)} + obj{np(str)} + {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)}
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)}
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)} + {cp(int)}
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)}
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}
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)}
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)}
kurczyć się: imperf: subj{np(str)} + {prepnp(z,gen)}
kurczyć się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
kusić: imperf: subj{cp(żeby)} + {np(str)}
kusić: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
kusić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kusić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
kusić: imperf: subj{np(str)} + {or}
kusić się: imperf: subj,controller{np(str)} + controlee{infp(_)}
kusić się: imperf: subj{np(str)} + {prepnp(na,acc)}
kusić się: imperf: subj{np(str)} + {prepnp(o,acc)}
kwestionować: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
kwestionować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
kwitnąć: imperf: subj{np(str)} + {np(inst)}
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)}
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)}
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)}
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(inst)}
leczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
leczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
leczyć się: imperf: subj{np(str)} + {prepnp(na,acc)}
leczyć się: imperf: subj{np(str)} + {prepnp(u,gen)}
leczyć się: imperf: subj{np(str)} + {prepnp(z,gen)}
leczyć się: imperf: subj{np(str)} + {xp(locat)}
lekceważyć: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
leżeć: imperf: subj,controller{np(str)} + controlee{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)}
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)} + {prepnp(z,gen)}
likwidować: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
likwidować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
lubić: imperf: subj,controller{np(str)} + controlee{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)}
ładować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
ładować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ł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)}
ł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ć 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)}
łapać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
łapać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
łapać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
łapać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
łapać się: imperf: subj{np(str)} + {prepnp(na,acc)}
łapać się: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
łapać się: imperf: subj{np(str)} + {prepnp(za,acc)}
łatać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(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)}
ł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)}
maleć: imperf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',ratr)}
maleć: imperf: subj{np(str)} + {prepnp(o,acc)}
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)}
marnować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
marnować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {lexnp(dat,_,'siebie',natr)}
marnować się: imperf: subj{np(str)}
marszczyć: imperf: subj{np(str)} + obj{np(str)}
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)} + {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)}
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{np(str)} + {cp(że)}
marzyć: imperf: subj{np(str)} + {or}
marzyć: imperf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
marzyć się: imperf: subj{cp(żeby)} + {np(dat)}
marzyć się: imperf: subj{cp(że)} + {np(dat)}
marzyć się: imperf: subj{np(str)} + {np(dat)}
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)}
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)} + {prepncp(o,loc,int)}
meldować: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
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(ż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)}
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ć: perf: subj,controller{np(str)} + controlee{np(inst)} + {refl}
mianować: perf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
mianować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
mieć: imperf: subj,controller{E} + controlee{infp(_)}
mieć: imperf: subj,controller{np(str)} + controlee{infp(_)}
mieć: imperf: subj,controller{np(str)} + controlee{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)} + controlee{infp(_)} + {lexnp(str,_,'przyczyna',atr)}
mieć: imperf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'obyczaj',atr)}
mieć: imperf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'pech',atr)}
mieć: imperf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'polecenie',natr)}
mieć: imperf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
mieć: imperf: subj,controller{np(str)} + controlee{infp(_)} + {lexnp(str,sg,'tendencja',atr)}
mieć: imperf: subj,controller{np(str)} + controlee{np(nom)} + {preplexnp(na,acc,sg,'imię',atr)}
mieć: imperf: subj,controller{np(str)} + controlee{np(nom)} + {preplexnp(na,acc,sg,'nazwisko',atr)}
mieć: imperf: subj,controller{np(str)} + controlee{prepadjp(za,acc)} + {refl}
mieć: imperf: subj,controller{np(str)} + controlee{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)} + {advp(misc)} + {preplexnp(w,loc,sg,'łeb',natr)}
mieć: imperf: subj{np(str)} + controller{cp(że)} + controlee{prepadjp(za,acc)} + {np(dat)}
mieć: imperf: subj{np(str)} + controller{np(str)} + controlee{prepadjp(za,acc)}
mieć: imperf: subj{np(str)} + controller{np(str)} + controlee{prepnp(za,acc)}
mieć: imperf: subj{np(str)} + controller{np(str); ncp(str,że)} + controlee{prepadjp(za,acc)} + {np(dat)}
mieć: imperf: subj{np(str)} + {ncp(str,że)} + {preplexnp(do,gen,_,'siebie',natr)}
mieć: imperf: subj{np(str)} + {np(str)} + {preplexnp(przed,inst,_,'siebie',natr)}
mieć: imperf: subj{np(str)} + {np(str)} + {preplexnp(za,loc,_,'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)} + controlee{xp(mod)} + {prepnp(do,gen)}
mieć się: imperf: subj,controller{np(str)} + controlee{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)}
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)}
mieszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mieszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
mieszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
mieszać się: imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
mieszać się: imperf: subj{np(str)} + {prepnp(do,gen)}
mieszać się: imperf: subj{np(str)} + {prepnp(w,acc)}
mieszać się: imperf: subj{np(str)} + {prepnp(z,inst)}
mieszkać: imperf: subj,controller{np(str)} + controlee{xp(mod)}
mieszkać: imperf: subj{np(str)} + {prepnp(u,gen)}
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(ż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,ż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)}
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)} + controlee{prepnp(jak,str)} + {prepnp(o,loc); prepncp(o,loc,że)}
milczeć: imperf: subj{np(str)} + {cp(int)}
milczeć: imperf: subj{np(str)} + {cp(że)}
milczeć: imperf: subj{np(str)} + {prepncp(o,loc,int)}
milczeć: imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
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)}
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)}
modlić się: imperf: subj{np(str)} + {np(inst)} + {or}
modlić się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,żeby)}
można: imperf: {infp(_)}
móc: imperf: subj,controller{E} + controlee{infp(_)}
móc: imperf: subj,controller{np(str)} + controlee{infp(_)}
móc: imperf: subj{np(str)} + {np(str)}
mówić: imperf: subj,controller{np(str)} + controlee{xp(mod)}
mówić: imperf: subj{ncp(str,int)} + {prepnp(o,loc)} + {nonch}
mówić: imperf: subj{ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
mówić: imperf: subj{np(str)} + {comprepnp(na temat)} + {cp(że)}
mówić: imperf: subj{np(str)} + controller{np(dat)} + controlee{np(nom)}
mówić: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controlee{xp(mod)}
mówić: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{np(nom)}
mówić: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controlee{xp(mod)}
mówić: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
mówić: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {ncp(str,że)}
mówić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
mówić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
mówić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
mówić: imperf: subj{np(str)} + obj{or} + {np(dat)} + {prepnp(o,loc)}
mówić: imperf: subj{np(str)} + obj{prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
mówić: imperf: subj{np(str)} + {prepadjp(po,postp)}
mówić: imperf: subj{np(str)} + {preplexnp(za,acc,_,'siebie',natr)}
mówić: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
mówić: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
mówić: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); or}
mówić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {cp(że)}
mówić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)} + {or}
mówić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
mówić: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)} + {prepnp(z,inst)}
mówić: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
mrugać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
mrugać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
mruknąć: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
mruknąć: perf: subj{np(str)} + {np(str)} + {prepnp(za,inst)}
mruknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
mruknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
mruknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
mruknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {or}
mścić: imperf: subj{np(str)} + obj{np(str)}
mścić się: imperf: subj{ncp(str,że)} + {prepnp(na,loc)}
mścić się: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepncp(za,acc,int)}
mścić się: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,że)}
musieć: imperf: subj,controller{E} + controlee{infp(_)}
musieć: imperf: subj,controller{np(str)} + controlee{infp(_)}
musieć: imperf: subj{np(str)} + {xp(adl)}
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)} + controlee{infp(_)}
myśleć: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controlee{prepadjp(jako,str)}
myśleć: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controlee{prepnp(jako,str)}
myśleć: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controlee{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); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nabić: perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: perf: subj{np(str)} + {np(dat)} + {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)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nabić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nabić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
nabierać: 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)}
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)}
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)}
nachylać: imperf: subj{np(str)} + {np(inst)} + {np(str)} + {prepnp(ku,dat)}
nachylać: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
nachylać: imperf: subj{np(str)} + {np(str)} + {prepnp(nad,inst)}
nachylać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
nachylać się: imperf: subj{np(str)} + {prepnp(ku,dat)}
nachylać się: imperf: subj{np(str)} + {prepnp(nad,inst)}
nacierać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {or}
nacierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)}
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)}
nadchodzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
nadejść: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
nadsyłać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nadsyłać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
nadsyłać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
nadzorować: imperf: subj{np(str)} + obj{np(str)}
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)} + {ncp(str,int)}
nagrać: perf: subj{np(str)} + obj{np(str)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nagrać się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nagrać się: perf: subj{np(str)} + {prepnp(na,loc)}
nagrać się: perf: subj{np(str)} + {xp(locat)}
nagrodzić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
nagrodzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nagrodzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nagrodzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nagrodzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
nagrodzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
nagrodzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nakładać: imperf: subj{np(str)} + {np(gen)}
nakładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
nakładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nakładać się: imperf: subj{np(str)} + {prepnp(na,acc)}
nakrywać: imperf: subj{np(str)} + {np(inst)} + {refl}
nakrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nakrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
nakrywać: imperf: subj{np(str)} + {prepnp(do,gen)}
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)}
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)}
nałożyć: perf: subj{np(str)} + {np(gen)}
nałożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
nałożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nałożyć się: perf: subj{np(str)} + {prepnp(na,acc)}
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)} + controlee{infp(_)}
namyślać się: imperf: subj{np(str)} + {cp(int)}
namyślać się: imperf: subj{np(str)} + {or}
namyślać się: imperf: subj{np(str)} + {prepncp(nad,inst,int)}
namyślać się: imperf: subj{np(str)} + {prepnp(nad,inst)}
napełniać: imperf: subj{ncp(str,że)} + obj{np(str)} + {np(inst)}
napełniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
napełniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napełniać się: imperf: subj{np(str)} + {np(inst)}
napić się: perf: subj{np(str)} + {np(gen)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
napić się: perf: subj{np(str)} + {np(inst)}
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(że)}
naprawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
naprawiać się: imperf: subj{np(str)}
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: 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)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
narazić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,acc)}
narazić się: perf: subj{np(str)} + {ncp(inst,że)}
narazić się: perf: subj{np(str)} + {np(dat)} + {np(inst)}
narazić się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
narazić się: perf: subj{np(str)} + {prepnp(dla,gen)}
narażać: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {refl}
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}
narodzić: perf: subj{np(str)} + {np(dat)} + {np(gen)}
narodzić się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
naruszać: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
naruszać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
naruszyć: perf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
naruszyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
narzekać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
narzekać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
narzekać: imperf: subj{np(str)} + {np(dat)} + {or}
narzekać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
narzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
narzucić się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
nastawiać: imperf: subj{np(str)} + controller{np(str)} + controlee{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)} + controlee{xp(mod)} + {prepnp(do,gen)}
nastawiać się: imperf: subj{np(str)} + {prepnp(na,acc)}
nastawić: perf: subj{np(str)} + controller{np(str)} + controlee{xp(mod)} + {prepnp(do,gen)}
nastawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nastawić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nastawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nastawić się: perf: subj,controller{np(str)} + controlee{xp(mod)} + {prepnp(do,gen)}
nastawić się: perf: subj{np(str)} + {prepnp(na,acc)}
nastąpić: perf: subj,controller{np(str)} + controlee{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)} + controlee{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)}
naśladować: imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
naśladować: imperf: subj{np(str)} + obj{np(str)}
nauczyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{infp(ndk)}
nauczyć: perf: subj{np(str)} + obj{np(str)} + {np(gen); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,żeby)}
nauczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)} + {nonch}
nauczyć się: perf: subj,controller{np(str)} + controlee{infp(ndk)}
nauczyć się: perf: subj,controller{np(str)} + obj,controlee{np(gen); cp(int); cp(że); ncp(gen,że); infp(ndk)} + {prepnp(od,gen); prepnp(z,gen)}
nauczyć się: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)}
nauczyć się: perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
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)}
nawiązywać: imperf: subj{np(str)} + {np(gen)}
nawiązywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
nawiązywać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
nawiązywać się: imperf: subj{np(str)} + {prepnp(między,inst)}
nawozić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nawozić: perf: subj{np(str)} + {np(gen)}
nawozić się: perf: subj{np(str)} + {np(gen)}
nazwać: perf: subj,controller{np(str)} + controlee{adjp(inst)} + {refl}
nazwać: perf: subj,controller{np(str)} + controlee{np(inst)} + {refl}
nazwać: perf: subj,controller{np(str)} + controlee{np(nom)} + {refl}
nazwać: perf: subj,controller{np(str)} + controlee{xp(mod)} + {refl}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(inst)}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{np(nom)}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{adjp(inst)} + {refl}
nazywać: imperf: subj,controller{np(str)} + controlee{np(inst)} + {refl}
nazywać: imperf: subj,controller{np(str)} + controlee{np(nom)} + {refl}
nazywać: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {refl}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(inst)}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{np(nom)}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
nazywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nazywać się: imperf: subj,controller{np(str)} + controlee{np(inst)}
nazywać się: imperf: subj,controller{np(str)} + controlee{np(nom)}
nazywać się: imperf: subj,controller{np(str)} + controlee{xp(mod)}
nienawidzić: imperf: subj{np(str)} + {infp(ndk)}
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(że)} + {np(str)}
niepokoić: imperf: subj{np(str); 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)}
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)}
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)}
nosić: imperf: {np(str)} + {xp(abl)} + {xp(adl)}
nosić: imperf: {np(str)} + {xp(perl)}
nosić: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
nosić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
nosić: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
nosić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
nosić: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nosić się: imperf: subj,controller{np(str)} + controlee{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(że)} + {np(str)}
nudzić: imperf: subj{ncp(str,że)} + {np(str)}
nudzić: imperf: subj{np(str)} + {cp(że)}
nudzić: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nudzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nudzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
nudzić: imperf: subj{np(str)} + {or}
nudzić: imperf: subj{np(str)} + {prepnp(o,loc)}
nudzić się: imperf: {np(dat)}
nudzić się: imperf: subj{np(str)} + {np(inst)}
obawiać się: imperf: subj,controller{np(str)} + controlee{infp(_)}
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)}
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)} + controlee{xp(mod)}
obchodzić się: imperf: subj{np(str)} + {np(inst)}
obchodzić się: imperf: subj{np(str)} + {prepnp(bez,gen)}
obciążać: imperf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
obciążać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obciążyć: perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
obciążyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarzyć się: perf: subj{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)} + controlee{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(w,acc)}
oberwać: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
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ć: perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(po,loc)}
oberwać: perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
oberwać się: perf: {np(dat)} + {prepnp(od,gen)} + {cp(że)}
oberwać się: perf: {np(dat)} + {prepnp(od,gen)} + {prepnp(za,acc); 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)}
obiecać: perf: subj,controller{np(str)} + controlee{infp(_)} + {np(dat)}
obiecać: perf: subj,controller{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
obiecać: perf: subj{np(str)} + {np(dat)} + {or}
obiecywać: imperf: subj,controller{np(str)} + obj,controlee{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)}
obiecywać: imperf: subj{np(str)} + obj{or} + {np(dat)}
objaśniać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
objaśniać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)}
objaśniać: imperf: subj{np(str)} + {or}
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)}
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)}
obliczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obliczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obliczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obliczyć się: perf: subj{np(str)} + {prepnp(na,acc)}
obmyślać: imperf: subj{np(str)} + {cp(int)}
obmyślać: imperf: subj{np(str)} + obj{np(str)}
obniżać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obniżać się: imperf: subj{np(str)}
obniżyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
obniżyć się: perf: subj{np(str)}
obowiązywać: imperf: subj{np(str)} + {np(str)}
obowiązywać: imperf: subj{np(str)} + {xp(dur)}
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ż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)}
obronić: perf: subj{np(str)} + {ncp(str,że)}
obronić: perf: subj{np(str)} + {np(inst)} + {refl}
obronić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obronić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
obronić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
obronić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
obronić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
obronić: perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
obronić: perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
obronić się: perf: subj{np(str)} + {np(dat)}
obronić się: perf: subj{np(str)} + {xp(locat)}
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)}
obserwować: imperf: subj{np(str)} + {cp(int)}
obserwować: imperf: subj{np(str)} + {cp(że)}
obserwować: imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
obsługiwać: imperf: subj{np(str)} + obj{np(str)}
obsługiwać: imperf: subj{np(str)} + {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)} + controlee{adjp(inst)}
obudzić się: perf: subj,controller{np(str)} + controlee{np(inst)}
obudzić się: perf: subj{np(str)} + {prepnp(w,loc)}
obudzić się: perf: subj{np(str)} + {prepnp(z,gen)}
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}
ocalić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
ocalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
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)} + controlee{prepadjp(jako,str)} + {refl}
oceniać: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
oceniać: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)}
oceniać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
oceniać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)} + {refl}
ocenić: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
ocenić: perf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)}
ocenić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
ocenić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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}
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)}
oczyszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
oczyszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oczyszczać się: imperf: subj{np(str)} + {prepnp(z,gen)}
oczyścić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
oczyścić: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
oczyścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oczyścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odbić: perf: {np(dat)}
odbić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbić: perf: subj{np(str)} + {np(str)} + {prepnp(na,loc)}
odbić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odbić: perf: subj{np(str)} + {xp(abl)}
odbić: perf: subj{np(str)} + {xp(adl)}
odbić się: perf: {np(dat)} + {np(inst)}
odbić się: perf: subj{np(str)} + controller{prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)} + controlee{xp(mod)}
odbić się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odbić się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
odbić się: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbić się: perf: subj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
odbić się: perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(inst,sg,'echo',atr)}
odbić się: perf: subj{np(str)} + {xp(locat)} + {lexnp(inst,sg,'echo',atr)}
odbierać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{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)}
odbyć: perf: subj{np(str)} + obj{np(str)}
odbyć się: perf: subj,controller{np(str)} + controlee{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)} + controlee{xp(mod)}
odbywać się: imperf: subj{np(str)} + {xp(locat)}
odbywać się: imperf: subj{np(str)} + {xp(temp)}
odchodzić: imperf: subj{np(str)} + {prepnp(do,gen)}
odchodzić: imperf: subj{np(str)} + {prepnp(na,acc)}
odchodzić: imperf: subj{np(str)} + {prepnp(od,gen)}
odchodzić: imperf: subj{np(str)} + {prepnp(z,gen)}
odchodzić: imperf: subj{np(str)} + {prepnp(z,inst)}
odchylać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odchylać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odchylać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odchylać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(od,gen)}
odczekać: perf: subj{np(str)} + {np(str)} + {cp(aż)}
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)} + controlee{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)} + controlee{xp(mod)}
odczytać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odczytać: perf: subj{np(str)} + {or}
odczytać: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
odczytać: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
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)} + controlee{xp(mod)} + {np(inst); prepnp(przez,acc)}
oddychać: imperf: subj{np(str)} + {np(inst); prepnp(przez,acc)}
oddziaływać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{xp(mod)} + {np(inst)}
oddziaływać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
oddzielić: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {refl}
oddzielić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
oddzielić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odebrać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
odegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odegrać się: perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
odegrać się: perf: subj{np(str)} + {xp(locat)}
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: {np(dat)} + {np(str)}
odejść: perf: subj{np(str)} + {prepnp(do,gen)}
odejść: perf: subj{np(str)} + {prepnp(na,acc)}
odejść: perf: subj{np(str)} + {prepnp(od,gen)}
odejść: perf: subj{np(str)} + {prepnp(z,gen)}
odejść: perf: subj{np(str)} + {prepnp(z,inst)}
odeprzeć: perf: subj{np(str)} + {cp(żeby)}
odeprzeć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
odeprzeć: perf: subj{np(str)} + {np(dat)} + {or}
odeprzeć: perf: subj{np(str)} + obj{np(str)}
oderwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oderwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oderwać się: perf: subj{np(str)} + {prepnp(od,gen)}
odesłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odesłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odesłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
odesłać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odezwać się: perf: subj{np(str)} + controller{prepnp(do,gen)} + controlee{xp(mod)} + {or}
odezwać się: perf: subj{np(str)} + controller{prepnp(o,loc)} + controlee{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)}
odgrywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odgrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odgrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odgrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odgrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odgrywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odgrywać się: imperf: subj{np(str)}
odgrywać się: imperf: subj{np(str)} + {np(dat)}
odgrywać się: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepncp(za,acc,int)}
odgrywać się: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,że)}
odgrywać się: imperf: subj{np(str)} + {xp(locat)}
odjechać: perf: subj{np(str)} + {np(inst)}
odjechać: perf: subj{np(str)} + {xp(abl)}
odjechać: perf: subj{np(str)} + {xp(adl)}
odjechać: perf: subj{np(str)} + {xp(temp)}
odjeżdżać: imperf: subj{np(str)} + {np(inst)}
odjeżdżać: imperf: subj{np(str)} + {xp(abl)}
odjeżdżać: imperf: subj{np(str)} + {xp(adl)}
odjeżdżać: imperf: subj{np(str)} + {xp(temp)}
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)}
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)}
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)} + {prepnp(na,acc)}
odłożyć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odłożyć się: perf: subj{np(str)} + {xp(locat)}
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)}
odnaleźć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odnaleźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
odnaleźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odnaleźć się: perf: subj{np(str)} + {prepnp(w,loc)}
odnaleźć się: perf: subj{np(str)} + {xp(locat)}
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)} + controlee{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)} + controlee{xp(mod)}
odnotować: perf: subj{np(str)} + obj{cp(int)}
odnotować: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {xp(locat)}
odnotować: perf: subj{np(str)} + {or}
odnowić: perf: subj{np(str)} + obj{np(str)}
odnowić się: perf: subj{np(str)} + {np(dat)} + {xp(temp)}
odnowić się: perf: subj{np(str)} + {prepnp(po,loc)}
odnowić się: perf: subj{np(str)} + {prepnp(u,gen)}
odpisać: perf: subj{np(str)} + {np(dat)} + {cp(int)}
odpisać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
odpisać: perf: subj{np(str)} + {np(dat)} + {or}
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(o,loc)}
odpisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odpisać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
odpisać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odpłynąć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpłynąć: perf: subj{np(str)} + {np(inst)} + {xp(abl)}
odpłynąć: perf: subj{np(str)} + {np(inst)} + {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,controller{np(str)} + controlee{xp(mod)} + {np(dat)} + {prepnp(na,acc)}
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)} + controlee{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)}
odprowadzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odprowadzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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)}
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)} + controlee{prepadjp(jako,str)} + {prepnp(od,gen)}
odrzucać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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ł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)}
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)}
odsunąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsunąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odsunąć się: perf: subj{np(str)} + {prepnp(od,gen)}
odsunąć się: perf: subj{np(str)} + {xp(adl)}
odsuwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsuwać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)}
odsyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odsyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
odsyłać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odtrącać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odtrącać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odtrącić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odtrącić: perf: subj{np(str)} + obj{np(str)} + {or}
odtrącić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odtworzyć: perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
odtworzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odtworzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odtworzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odtworzyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odtworzyć się: perf: subj{np(str)}
odważyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odważyć się: perf: subj,controller{np(str)} + controlee{infp(_)}
odważyć się: perf: subj{np(str)} + {cp(żeby)}
odważyć się: perf: subj{np(str)} + {or}
odważyć się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
odwiedzać: imperf: subj{np(str)} + obj{np(str)}
odwiedzić: perf: subj{np(str)} + obj{np(str)}
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)}
odwoływać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odwoływać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odwoływać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
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)}
odzwyczajać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odzwyczajać się: imperf: subj{np(str)} + {prepnp(od,gen)}
odzyskać: perf: subj{np(str)} + obj{np(str)}
odzywać się: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controlee{xp(mod)} + {or}
odzywać się: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controlee{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żywiać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
odżywiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odżywiać się: imperf: subj,controller{np(str)} + controlee{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{np(str)} + {np(dat)} + {cp(że)}
oferować się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
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(przez,acc)}
ofiarować: _: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
ofiarować: _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ofiarować się: _: subj,controller{np(str)} + controlee{infp(_)}
ofiarować się: _: subj{np(str)} + {cp(że)}
ofiarować się: _: subj{np(str)} + {or}
ofiarować się: _: subj{np(str)} + {prepnp(z,inst)}
ogarnąć: perf: subj{np(str)} + obj{np(str)}
ogarnąć się: perf: subj{np(str)} + {prepnp(z,gen)}
ogarnąć się: perf: subj{np(str)} + {prepnp(z,inst)}
oglądać: imperf: subj{np(str)} + {cp(int)}
oglądać: imperf: subj{np(str)} + {cp(jak)}
oglądać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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(czy)}
oglądać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
oglądać: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
oglądać: imperf: subj{np(str)} + {xp(locat)} + {refl}
oglądać się: imperf: subj{np(str)} + {cp(int)}
oglądać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(czy)}
oglądać się: imperf: subj{np(str)} + {prepnp(za,inst)}
ogłaszać: imperf: subj,controller{np(str)} + controlee{np(inst)} + {refl}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(inst)}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(za,acc)}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{np(inst)} + {refl}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(inst)}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(za,acc)}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
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)} + controlee{adjp(pred)}
okazać się: perf: subj,controller{np(str)} + controlee{infp(_)}
okazać się: perf: subj,controller{np(str)} + controlee{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)} + controlee{adjp(pred)}
okazywać się: imperf: subj,controller{np(str)} + controlee{infp(_)}
okazywać się: imperf: subj,controller{np(str)} + controlee{np(inst)}
okazywać się: imperf: subj{cp(int)}
okazywać się: imperf: subj{cp(że)}
okradać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
określać: imperf: subj,controller{np(str)} + controlee{prepadjp(jako,str)} + {refl}
określać: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)}
określać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
określać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
określać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
określić: perf: subj,controller{np(str)} + controlee{prepadjp(jako,str)} + {refl}
określić: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
określić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
określić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
omawiać: imperf: subj{np(str)} + obj{np(str)}
omijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
omijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
omijać się: imperf: subj{np(str)} + {prepnp(z,inst)}
omówić: perf: subj{np(str)} + obj{np(str)}
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)}
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)}
opatrzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opatrzyć: perf: subj{np(str)} + obj{np(str)} + {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)}
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)}
opisać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
opisać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
opłacać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
opłacać się: imperf: subj,controlee{infp(_)} + controller{np(dat)}
opłacać się: imperf: subj{np(str)} + {np(dat)}
opłacić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opłacić się: perf: subj,controlee{infp(_)} + controller{np(dat)}
opłacić się: perf: subj{np(str)} + {np(dat)}
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)}
opracować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opracować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
opuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
opuszczać: imperf: subj{np(str)} + {xp(adl)} + {refl}
opuszczać się: imperf: subj{np(str)} + {prepnp(w,loc)}
opuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
opuścić: perf: subj{np(str)} + {xp(adl)} + {refl}
opuścić się: perf: subj{np(str)} + {prepnp(w,loc)}
orać: imperf: subj,controller{np(str)} + controlee{xp(mod)}
orać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
orać: imperf: subj{np(str)} + {prepnp(w,acc)}
organizować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
organizować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
organizować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
organizować się: imperf: subj{np(str)} + {cp(żeby)}
organizować się: imperf: subj{np(str)} + {prepnp(do,gen)}
organizować się: imperf: subj{np(str)} + {prepnp(w,acc)}
organizować się: imperf: subj{np(str)} + {prepnp(wobec,gen)}
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)}
osiągać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
osiągnąć: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
osiedlać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
osiedlać się: imperf: subj{np(str)} + {xp(locat)}
oskarżać: imperf: subj{np(str)} + {cp(że)} + {refl}
oskarżać: imperf: subj{np(str)} + {np(str)} + {or}
oskarżać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oskarżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
oskarżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
oskarżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
oskarżać: imperf: subj{np(str)} + {or} + {refl}
oskarżać: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,ż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(za,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or}
oskarżyć: perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
osłabiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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}
ostrzyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ostrzyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ostrzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oswoić: perf: subj{np(str)} + obj{np(str)} + {prepncp(z,inst,int)}
oswoić: perf: subj{np(str)} + obj{np(str)} + {prepncp(z,inst,że)}
oswoić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
oswoić się: perf: subj{np(str)} + {prepncp(z,inst,int)}
oswoić się: perf: subj{np(str)} + {prepncp(z,inst,że)}
oswoić się: perf: subj{np(str)} + {prepnp(z,inst)}
oszacować: perf: subj{np(str)} + {cp(że)}
oszacować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oszaleć: perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
oszaleć: perf: subj{np(str)} + {prepnp(dla,gen)}
oszaleć: perf: subj{np(str)} + {prepnp(od,gen)}
oszaleć: perf: subj{np(str)} + {prepnp(za,inst)}
oszaleć: perf: subj{np(str)} + {prepnp(z,gen)}
oszczędzać: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
oszczędzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oszczędzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
oszczędzać: imperf: subj{np(str)} + {refl}
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)}
ośmielać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {or}
ośmielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,inst)}
ośmielać się: imperf: subj,controller{np(str)} + controlee{infp(_)}
ośmielać się: imperf: 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)}
otaczać: imperf: subj{np(str)} + {np(inst)} + {refl}
otaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
otoczyć: perf: subj{np(str)} + {np(inst)} + {refl}
otoczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otruć: perf: subj{np(str)} + {np(inst)} + {refl}
otruć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
otwierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
otwierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
otwierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
otwierać się: imperf: subj{np(str)} + {np(dat)}
otworzyć: perf: subj,controller{np(str)} + controlee{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)} + controlee{xp(mod)}
otworzyć się: perf: subj{np(str)} + {np(dat)}
oznaczać: imperf: {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)} + controlee{prepadjp(jako,str)}
oznaczać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
oznaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
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)}
pachnieć: imperf: controller{np(dat)} + controlee{infp(_)}
pachnieć: imperf: {np(inst)} + {xp(locat)}
pachnieć: imperf: {prepnp(od,gen)} + {xp(locat)}
pachnieć: imperf: subj,controller{np(str)} + controlee{xp(mod)}
pachnieć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnieć: imperf: subj{np(str)} + {prepnp(od,gen)}
pachnieć: imperf: {xp(locat)} + {xp(mod)}
padać: imperf: subj{E}
padać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
padać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
padać: imperf: subj{np(str)} + {prepnp(na,acc)}
padać: imperf: subj{np(str)} + {prepnp(z,gen)}
pakować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pakować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pakować: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pakować się: imperf: subj{np(str)} + {prepnp(w,acc)}
pakować się: imperf: subj{np(str)} + {xp(adl)}
palić: imperf: {np(str)} + {xp(locat)}
palić: imperf: subj{cp(żeby)} + {np(str)}
palić: imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
palić: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
palić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
palić: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'popiół',natr)}
palić się: imperf: {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
palić się: imperf: subj,controller{np(str)} + controlee{infp(_)}
palić się: imperf: subj{np(str)} + {cp(żeby)}
palić się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,pl,'noga',natr)}
palić się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,pl,'stopa',natr)}
palić się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,pl,'ręka',natr)}
palić się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
palić się: imperf: subj{np(str)} + {prepnp(z,gen)}
pamiętać: imperf: subj,controller{np(str)} + controlee{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)} + controlee{adjp(pred)}
pamiętać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
pamiętać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
panować: imperf: subj{np(str)} + {xp(locat)}
panować: imperf: subj{np(str)} + {xp(temp)}
parkować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pasować: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {np(dat)}
pasować: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepnp(na,acc)} + {np(inst)}
paść: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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,gen)}
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)}
patrzeć: imperf: {np(dat)} + {advp(misc)} + {preplexnp(z,gen,pl,'oko',atr)}
patrzeć: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{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)} + controlee{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)} + {cp(żeby)}
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)} + controlee{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)} + controlee{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)} + {cp(żeby)}
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)}
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)} + controlee{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łnić: imperf: subj{np(str)} + obj{np(str)}
pędzić: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
pędzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pędzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,loc)}
pędzić: imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
pędzić: imperf: subj{np(str)} + {prepnp(po,acc)}
pędzić: imperf: subj{np(str)} + {prepnp(za,inst)}
pędzić: imperf: subj{np(str)} + {xp(perl)}
pękać: imperf: subj{np(str)} + {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)}
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)}
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)}
pilnować: imperf: subj{np(str)} + {cp(int); cp(żeby)}
pilnować: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pilnować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,żeby)}
pilnować: imperf: subj{np(str)} + obj{np(str)} + {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)} + controlee{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)} + controlee{np(nom)}
pisać się: imperf: subj{np(str)} + {np(inst)}
pisać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
pisać się: imperf: subj{np(str)} + {prepnp(przez,acc)}
planować: imperf: subj,controller{np(str)} + controlee{infp(_)}
planować: imperf: subj{np(str)} + {cp(int)}
planować: imperf: subj{np(str)} + {cp(żeby)}
planować: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
planować: imperf: subj{np(str)} + {or}
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ł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ł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{np(str)} + {np(dat)} + {prepnp(z,gen)}
płynąć: imperf: subj{np(str)} + {np(inst)}
płynąć: imperf: subj{np(str)} + {prepnp(na,loc)}
płynąć: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
płynąć: imperf: subj{np(str)} + {xp(perl)}
pływać: imperf: subj{np(str)} + {np(inst)}
pływać: imperf: subj{np(str)} + {prepnp(na,loc)}
pływać: imperf: subj{np(str)} + {prepnp(w,loc)}
pływać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
pływać: imperf: subj{np(str)} + {xp(locat)}
pływać: imperf: subj{np(str)} + {xp(perl)}
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)} + controlee{infp(_)} + {prepnp(do,gen)}
pobiec: perf: subj,controller{np(str)} + controlee{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)}
pobierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
pobierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pobierać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pobierać się: imperf: subj{np(str)} + {prepnp(z,gen)}
pobierać się: imperf: subj{np(str)} + {prepnp(z,inst)}
pobrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pobrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pobrać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pobrać się: perf: subj{np(str)} + {prepnp(z,gen)}
pobrać 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)}
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)} + {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)}
pochylić: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
pochylić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
pochylić się: perf: subj{np(str)} + {prepnp(nad,inst)}
pochylić się: perf: subj{np(str)} + {prepnp(przed,inst)}
pociągać: imperf: subj{cp(żeby)} + {np(str)}
pociągać: imperf: subj{np(str)} + {cp(żeby)}
pociągać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
pociągać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pociągać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'odpowiedzialność',atr)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('za sobą')}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pociągać: imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
pociągnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pociągnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {fixed('za sobą')}
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(w,acc)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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}
począć: perf: subj{np(str)} + {infp(ndk)}
począć: perf: subj{np(str)} + obj{np(str)}
począć: perf: subj{np(str)} + {prepnp(z,inst)} + {nonch}
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)}
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,inst); prepnp(w,loc)}
poczuć: perf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
poczuć się: perf: subj,controller{np(str)} + controlee{adjp(pred)}
poczuć się: perf: subj,controller{np(str)} + controlee{infp(_)} + {preplexnp(na,loc,pl,'siła',natr)}
poczuć się: perf: subj,controller{np(str)} + controlee{infp(_)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
poczuć się: perf: subj,controller{np(str)} + controlee{np(inst)}
poczuć się: perf: subj,controller{np(str)} + controlee{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)}
podać: perf: subj{np(str)} + {advp(pron)}
podać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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(str)} + {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)} + controlee{prepadjp(za,acc)}
podać się: perf: subj,controller{np(str)} + controlee{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)} + controlee{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(str)} + {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)} + controlee{prepadjp(za,acc)}
podawać się: imperf: subj,controller{np(str)} + controlee{prepnp(za,acc)}
podawać się: imperf: subj{np(str)} + {prepnp(do,gen)}
podchodzić: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controlee{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)}
poddać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
poddać: perf: subj{np(str)} + {or}
poddać się: perf: subj{np(str)} + {np(dat)}
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)} + controlee{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)}
podejrzewać: imperf: subj{np(str)} + obj{cp(int)}
podejrzewać: imperf: subj{np(str)} + obj{cp(że)}
podejrzewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
podejść: perf: subj{np(str)} + controller{prepnp(do,gen)} + controlee{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)}
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)}
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)} + controlee{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)}
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}
podlegać: imperf: subj{np(str)} + {np(dat)}
podłączyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podłączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podłączyć się: perf: subj{np(str)} + {prepnp(do,gen)}
podłączyć się: perf: subj{np(str)} + {prepnp(pod,acc)} + {or}
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)}
podnosić: imperf: subj{np(str)} + obj{np(str)} + {or}
podnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
podnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podnosić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(locat)}
podnosić się: imperf: subj{np(str)} + {or}
podnosić się: imperf: subj{np(str)} + {prepnp(z,gen)}
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)}
podpisać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
podpisać się: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
podpisać się: perf: subj{np(str)} + {cp(że)}
podpisać się: perf: subj{np(str)} + {np(inst)} + {prepncp(pod,loc,żeby)}
podpisać się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
podpisać się: perf: subj{np(str)} + {np(inst)} + {prepnp(pod,inst)}
podpisać się: perf: subj{np(str)} + {prepncp(pod,loc,że)}
podpisywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podpisywać się: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
podpisywać się: imperf: subj{np(str)} + {cp(że)}
podpisywać się: imperf: subj{np(str)} + {np(inst)} + {prepncp(pod,inst,żeby)}
podpisywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
podpisywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,inst)}
podpisywać się: imperf: subj{np(str)} + {prepncp(pod,inst,że)}
podporządkować: perf: subj{np(str)} + {np(dat)} + {refl}
podporządkować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
podróżować: imperf: subj,controller{np(str)} + controlee{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)}
podrzeć: perf: subj{np(str)} + obj{np(str)}
podrzeć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
podtrzymywać: imperf: subj{np(str)} + {np(inst)} + {refl}
podtrzymywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {or}
podtrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {or}
podtrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
podtrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
podtrzymywać: imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
podtrzymywać: imperf: subj{np(str)} + {prepnp(przy,loc)} + {refl}
podtrzymywać: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
podwyższyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podwyższyć się: perf: subj{np(str)} + {prepnp(o,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)} + controlee{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}
pogłębiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogłębiać się: imperf: subj{np(str)}
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)}
pogorszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogorszyć się: perf: subj{np(str)} + {np(dat)}
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)}
pojawiać się: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
pojawiać się: imperf: subj{np(str)} + {xp(abl)}
pojawić się: perf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
pojawić się: perf: subj{np(str)} + {xp(abl)}
pojąć: perf: subj{np(str)} + {cp(int); cp(że)}
pojąć: perf: subj{np(str)} + {ncp(str,int)}
pojąć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
pojąć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
pojechać: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
pojechać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); xp(adl)} + {xp(perl)}
pojechać: perf: subj{np(str)} + {np(inst)} + {prepnp(na,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)} + controlee{prepadjp(jako,str)}
pojmować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
pojmować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
pokazać: perf: subj{np(str)} + controller{np(str)} + controlee{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)} + controlee{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)} + controlee{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)} + controlee{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)}
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)}
pokonać: perf: subj{np(str)} + obj{np(str)}
pokonywać: imperf: subj{np(str)} + obj{np(str)}
pokryć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokryć się: perf: subj{np(str)} + {np(inst)}
pokrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pokrywać się: imperf: subj{np(str)} + {np(inst)}
pokwitować: perf: subj{np(str)} + {np(inst)} + {cp(że)}
pokwitować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
polecać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
polecać: imperf: subj{np(str)} + {np(dat)} + {infp(_)}
polecać: imperf: subj{np(str)} + {np(dat)} + {or}
polecać: imperf: subj{np(str)} + {np(dat)} + {refl}
polecać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
polecać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
polecać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
polecić: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
polecić: imperf: subj{np(str)} + {np(dat)} + {infp(_)}
polecić: imperf: subj{np(str)} + {np(dat)} + {or}
polecić: imperf: subj{np(str)} + {np(dat)} + {refl}
polecić: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)} + {np(dat)}
polecić: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)} + {np(dat)}
polecić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
polecić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
polecieć: perf: subj,controller{np(str)} + controlee{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)}
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łknąć: perf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
połknąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
położyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{infp(ndk)}
położyć: perf: subj{np(str)} + obj{lexnp(str,pl,'ucho',natr)} + {preplexnp(po,loc,_,'siebie',natr)}
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)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
położyć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
położyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
położyć się: perf: subj,controller{np(str)} + controlee{infp(ndk)}
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)}
pomagać: imperf: subj{cp(że)} + {np(dat)}
pomagać: imperf: subj{np(str)} + controller{np(dat)} + controlee{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)}
pomijać: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {lexnp(inst,sg,'milczenie',atr)}
pomijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
pomijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pominąć: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {lexnp(inst,sg,'milczenie',atr)}
pominąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
pominąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pomóc: perf: subj{cp(że)} + {np(dat)}
pomóc: perf: subj{np(str)} + controller{np(dat)} + controlee{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)}
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)} + {cp(żeby)}
pomyśleć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pomyśleć: perf: subj{np(str)} + {prepnp(o,loc)} + {nonch}
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)}
ponosić: imperf: subj{np(str)} + obj{np(str)}
popatrzeć: perf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{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)} + controlee{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)}
popełnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poprawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprawiać się: imperf: subj{np(str)} + {np(dat)}
poprawiać się: imperf: subj{np(str)} + {prepnp(w,loc)}
poprawiać się: imperf: subj{np(str)} + {prepnp(z,gen)}
poprawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poprawić się: perf: subj{np(str)} + {np(dat)}
poprawić się: perf: subj{np(str)} + {prepnp(w,loc)}
poprawić się: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
poprzeć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poprzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poprzedzać: imperf: subj{ncp(str,że)} + obj{np(str)}
poprzedzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pora: imperf: {cp(żeby)}
pora: imperf: {np(dat)} + {infp(_)}
pora: imperf: {prepnp(na,acc); prepncp(na,acc,żeby)}
poradzić: perf: subj{np(str)} + controller{np(dat)} + controlee{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)}
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)}
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}
porównywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
porównywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
porównywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
porównywać: imperf: 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)} + controlee{xp(mod)} + {prepnp(w,loc)}
poruszać się: imperf: subj{np(str)} + {np(inst)}
poruszać się: imperf: subj{np(str)} + obj{np(str)}
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)}
porzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,acc)}
porzucić: perf: subj{np(str)} + obj{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,inst)}
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)} + {ncp(loc,jak)}
posłuchać: imperf: subj{np(str)} + {np(gen); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
posłuchać: imperf: subj{np(str)} + {np(str)}
posłuchać się: imperf: subj{np(str)} + {np(gen)}
posługiwać: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepnp(jako,str)} + {np(dat)}
posłużyć: perf: subj,controller{np(str)} + controlee{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)}
postanowić: perf: subj,controller{np(str)} + controlee{infp(_)}
postanowić: perf: subj{np(str)} + {cp(int)}
postanowić: perf: subj{np(str)} + {cp(że)}
postanowić: perf: subj{np(str)} + {cp(żeby)}
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)} + controlee{infp(_)}
postarać się: perf: subj{np(str)} + {cp(żeby)}
postarać się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
postawić: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {cp(że)}
postawić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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,loc,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ąpić: perf: subj,controller{np(str)} + controlee{xp(mod)} + {comprepnp(w kwestii)}
postąpić: perf: subj,controller{np(str)} + controlee{xp(mod)} + {comprepnp(w sprawie)}
postąpić: perf: subj{np(str)} + controller{prepnp(z,inst)} + controlee{xp(mod)}
postąpić: perf: subj{np(str)} + {np(str)} + {xp(adl)}
postąpić: perf: subj{np(str)} + {prepnp(o,acc)} + {xp(adl)}
postępować: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {prepnp(wobec,gen)}
postępować: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {prepnp(względem,gen)}
postępować: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {prepnp(z,inst)}
postępować: imperf: subj{np(str)} + controller{prepnp(z,inst)} + controlee{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)}
postrzegać: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
postrzegać: imperf: subj{np(str)} + {cp(int)}
postrzegać: imperf: subj{np(str)} + {cp(że)}
postrzegać: imperf: subj{np(str)} + {ncp(str,int)}
postrzegać: imperf: subj{np(str)} + {ncp(str,że)}
postrzegać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
postrzegać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
postrzegać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
posuwać: imperf: subj{np(str)} + {np(inst)}
posuwać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
posuwać: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
posuwać się: imperf: subj,controller{np(str)} + controlee{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)}
posuwać się: imperf: subj{np(str)} + {xp(perl)}
posyłać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
posyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
posyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
posyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
poszukiwać: imperf: subj{np(str)} + obj{np(gen)} + {xp(locat)}
pośliznąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
poślubić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
potrafić: imperf: subj,controller{np(str)} + controlee{infp(_)}
potrafić: imperf: subj{np(str)} + {np(str)}
potraktować: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
potraktować: perf: subj,controller{np(str)} + controlee{xp(mod)}
potraktować: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
potraktować: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
potraktować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
potrwać: perf: subj,controller{np(str)} + controlee{xp(mod)} + {xp(dur)}
potrzebować: imperf: subj,controller{np(str)} + controlee{infp(_)}
potrzebować: imperf: subj{np(str)} + {np(gen)}
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)}
powiadać: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {np(dat)} + {cp(że)}
powiadać: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {np(dat)} + {cp(żeby)}
powiadać: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {np(dat)} + {np(str)} + {or}
powiadać: imperf: subj,controller{np(str)} + controlee{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)}
powiązać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powiązać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
powiązać się: perf: subj{np(str)} + {prepnp(z,inst)}
powiedzieć: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{np(nom)}
powiedzieć: imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {cp(że)}
powiedzieć: imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {or}
powiedzieć: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
powiedzieć: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {ncp(str,że)}
powiedzieć: imperf: subj{np(str)} + obj{cp(int)} + {prepnp(do,gen)}
powiedzieć: imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(do,gen)}
powiedzieć: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(do,gen)} + {prepnp(o,loc)}
powiedzieć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
powiedzieć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
powiedzieć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
powiedzieć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
powiedzieć: imperf: subj{np(str)} + obj{or} + {np(dat)} + {prepnp(o,loc)}
powiedzieć: imperf: subj{np(str)} + obj{or} + {prepnp(do,gen)} + {comprepnp(na temat)}
powiedzieć: imperf: subj{np(str)} + obj{or} + {prepnp(do,gen)} + {prepnp(o,loc)}
powiedzieć: imperf: subj{np(str)} + obj{prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
powiedzieć: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepncp(o,loc,że)}
powierzyć: perf: subj{np(str)} + {np(dat)} + {refl}
powierzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powiesić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
powiesić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
powiesić: perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
powieść: 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(adl)}
powieść się: perf: {np(dat)} + {prepnp(w,loc)} + {xp(mod)}
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} + controlee{infp(_)}
powodować: imperf: subj{ncp(str,że)} + obj{np(str)}
powodować: imperf: subj{np(str)} + {cp(że)}
powodować: imperf: subj{np(str)} + {ncp(str,że)}
powodować: imperf: subj{np(str)} + {np(inst)}
powodować: imperf: subj{np(str)} + obj{np(str)}
powodować się: imperf: subj{np(str)} + {np(inst)}
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)}
powoływać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powoływać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powoływać się: imperf: 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,inst)} + {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)}
powstrzymać: perf: subj{ncp(str,że)} + obj{np(str)}
powstrzymać: perf: subj{np(str)} + {cp(żeby)} + {refl}
powstrzymać: perf: subj{np(str)} + {np(inst)}
powstrzymać: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
powstrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
powstrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
powstrzymać: perf: subj{np(str)} + {or}
powstrzymać: perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
powstrzymać: perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
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)}
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)}
pozbyć się: perf: subj{np(str)} + {np(gen)} + {xp(abl)}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {or}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)} + controlee{infp(_)}
pozostać: perf: subj,controller{np(str)} + controlee{adjp(pred)}
pozostać: perf: subj,controller{np(str)} + controlee{np(inst)}
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)} + {prepnp(u,gen); xp(locat)}
pozostawać: imperf: subj,controlee{infp(_)} + controller{np(dat)}
pozostawać: imperf: subj,controller{np(str)} + controlee{adjp(pred)}
pozostawać: imperf: subj,controller{np(str)} + controlee{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(u,gen); xp(locat)}
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ć: perf: subj,controller{np(str)} + controlee{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',natr)}
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',natr)}
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)}
pozwalać: imperf: subj{np(str)} + controller{np(dat)} + controlee{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)} + controlee{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)}
pozyskiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozyskiwać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pożegnać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pożegnać się: perf: subj{np(str)} + {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)}
pożyczyć: perf: subj{np(str)} + {np(dat)} + {np(gen)}
pożyczyć: perf: subj{np(str)} + {np(dat)} + {or}
pożyczyć: perf: subj{np(str)} + obj{np(part)} + {np(dat)}
pożyczyć: perf: subj{np(str)} + obj{np(part)} + {prepnp(od,gen)}
pożyczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pożyczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
pożyczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
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: {np(dat)} + {xp(mod)}
pójść: perf: subj,controller{np(str)} + controlee{infp(_)} + {xp(adl)}
pójść: perf: subj,controller{np(str)} + controlee{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)} + controlee{prepnp(jako,str)}
pracować: imperf: subj,controller{np(str)} + controlee{xp(mod)}
pracować: imperf: subj{np(str)} + {comprepnp(na rzecz)}
pracować: imperf: subj{np(str)} + {prepnp(dla,gen)}
pracować: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pracować: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
pracować: imperf: subj{np(str)} + {prepnp(na,loc)}
pracować: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
pracować: imperf: subj{np(str)} + {prepnp(przy,loc)}
pracować: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
prać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
prać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
prać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
prać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
prać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
prać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
prać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
prać się: imperf: subj{np(str)}
pragnąć: imperf: subj,controller{np(str)} + controlee{cp(żeby); infp(_)}
pragnąć: imperf: subj{np(str)} + {np(gen); ncp(str,żeby)}
prasować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prezentować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
prezentować się: imperf: subj,controller{np(str)} + controlee{xp(mod)}
prezentować się: imperf: subj{np(str)} + {prepnp(w,loc)}
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)} + {prepnp(przed,inst)}
projektować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
promować: imperf: subj{np(str)} + {np(inst)} + {refl}
promować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
promować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
promować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)} + controlee{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)}
prosić: imperf: {np(gen)}
prosić: imperf: subj,controller{np(str)} + controlee{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)}
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)} + controlee{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)} + controlee{xp(mod)}
próbować: imperf: subj,controller{np(str)} + controlee{infp(_)}
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ć się: imperf: subj{np(str)} + {prepnp(z,inst)}
przebaczać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przebaczać: imperf: subj{np(str)} + {np(dat)} + {ncp(str,że)}
przebaczać: imperf: subj{np(str)} + {np(dat)} + {prepncp(za,acc,że)}
przebaczać: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
przebaczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebiegać: imperf: subj,controller{np(str)} + controlee{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)} + {prepnp(do,gen)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)} + {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}
przebywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)} + {xp(locat)}
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)}
przechowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
przechowywać: imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przechowywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przechowywać się: imperf: subj{np(str)} + {prepnp(u,gen)}
przechowywać się: imperf: subj{np(str)} + {xp(locat)}
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)}
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)}
przeczytać: perf: subj{np(str)} + {cp(żeby)}
przeczytać: perf: subj{np(str)} + {np(dat)} + {cp(int)}
przeczytać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przeczytać: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
przeczytać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
przeczytać: perf: subj{np(str)} + {prepnp(o,loc)} + {cp(int)}
przeczytać: perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
przeczytać: perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(w,loc)}
przeczytać: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
przeczytać: perf: subj{np(str)} + {prepnp(z,gen)}
przedkładać: imperf: subj{np(str)} + {cp(że); cp(żeby)}
przedkładać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
przedłożyć: perf: subj{np(str)} + {cp(że); cp(żeby)}
przedłożyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)} + {np(dat)}
przedłożyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)} + {np(dat)}
przedłożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
przedłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
przedłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,acc)}
przedłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
przedłużać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przedłużać się: imperf: subj{np(str)} + {prepnp(o,acc)}
przedłużyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
przedłużyć się: perf: subj{np(str)} + {prepnp(o,acc)}
przedsiębrać: imperf: subj{np(str)} + obj{np(str)}
przedstawiać: imperf: subj,controller{np(str)} + controlee{prepadjp(jako,str)} + {np(dat)} + {refl}
przedstawiać: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)} + {np(dat)}
przedstawiać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)} + {np(dat)}
przedstawiać się: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {np(dat)}
przedstawiać się: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)} + {np(dat)} + {refl}
przedstawić: perf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)} + {np(dat)}
przedstawić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{np(inst)} + {np(dat)}
przedstawić się: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {np(dat)}
przedstawić się: perf: subj,controller{np(str)} + controlee{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)}
przeglądać: imperf: subj{np(str)} + obj{np(str)}
przeglądać się: imperf: subj{np(str)} + {prepnp(w,loc)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przegrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przegrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przegrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przegrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przegrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przejawiać: imperf: subj{np(str)} + obj{np(str)}
przejawiać się: imperf: subj,controller{np(str)} + controlee{prepadjp(jako,str)}
przejawiać się: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
przejawiać się: imperf: subj,controller{np(str)} + controlee{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)}
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)}
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)}
przekładać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekładać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przekładać: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przekładać się: imperf: subj{np(str)} + {prepnp(na,acc)}
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)}
przekraczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekreślać: imperf: subj{np(str)} + obj{np(str)}
przekroczyć: perf: subj{np(str)} + obj{np(str)}
przekształcać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(na,acc)} + {prepadjp(z,gen)}
przekształcać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{prepadjp(na,acc)} + {prepadjp(z,gen)}
przekształcać się: imperf: subj,controller{np(str)} + controlee{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)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przelewać się: imperf: subj{np(str)} + {np(dat)}
przelewać się: imperf: subj{np(str)} + {prepnp(przez,acc)}
przelewać się: imperf: subj{np(str)} + {xp(perl)}
przełamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przełamać się: perf: subj{np(str)} + {cp(żeby)}
przełamać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przełamać się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przełożyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przełożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przełożyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przełożyć: perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przełożyć się: perf: subj{np(str)} + {prepnp(na,acc)}
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ó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)}
przenieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przenieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przenieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przenieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przenieść: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przenieść się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przenieść się: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przenieść się: perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przenieść się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przenosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przenosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przenosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przenosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przenosić: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przenosić się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przenosić się: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przenosić się: imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przenosić się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przepisać się: perf: subj{np(str)} + {prepnp(do,gen)}
przepisać się: perf: subj{np(str)} + {prepnp(na,acc)}
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,inst)}
przepłynąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przepłynąć: perf: subj{np(str)} + {prepnp(na,inst)} + {prepnp(przez,acc)}
przepłynąć się: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
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)}
przeprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przeprowadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przeprowadzać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzać się: imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przeprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przeprowadzić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przeprowadzić: perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przeprowadzić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
przeprowadzić się: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
przeprowadzić się: perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
przeprowadzić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przerazić: perf: subj{cp(że)} + {np(str)}
przerazić: perf: subj{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)} + {ncp(gen,int)}
przerazić się: perf: subj{np(str)} + {ncp(gen,że)}
przerazić się: perf: subj{np(str)} + {ncp(inst,int)}
przerazić się: perf: subj{np(str)} + {ncp(inst,że)}
przerazić się: perf: subj{np(str)} + {np(gen)}
przerazić się: perf: subj{np(str)} + {np(inst)}
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)}
przesadzać: imperf: subj{np(str)} + {np(str)} + {prepnp(przez,acc)}
przesadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesadzać: imperf: subj{np(str)} + {prepncp(w,loc,int)}
przesadzać: imperf: subj{np(str)} + {prepncp(z,inst,int)}
przesadzać: imperf: subj{np(str)} + {prepncp(z,inst,że)}
przesadzać: imperf: subj{np(str)} + {prepncp(z,inst,żeby)}
przesadzać: imperf: subj{np(str)} + {prepnp(w,loc)}
przesadzać: imperf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
przestać: perf: subj,controller{E} + controlee{infp(ndk)}
przestać: perf: subj{np(str)} + obj{np(str)}
przestawać: imperf: subj,controller{E} + controlee{infp(ndk)}
przestawać: imperf: subj{np(str)} + {prepnp(na,loc)}
przestawać: imperf: subj{np(str)} + {prepnp(z,inst)}
przestraszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przestraszyć się: perf: subj{np(str)} + {cp(że)}
przestraszyć się: perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {or}
przestraszyć się: perf: subj{np(str)} + {np(inst)} + {or}
przestrzegać: imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
przestrzegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); cp(że); cp(żeby); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
przesunąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przesunąć: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przesunąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przesunąć: perf: subj{np(str)} + obj{np(str)} + {prepncp(za,acc,że)}
przesunąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przesunąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
przesunąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesunąć: perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przesunąć się: perf: subj{np(str)} + {cp(żeby)}
przesunąć się: perf: subj{np(str)} + {prepnp(o,acc)}
przesunąć się: perf: subj{np(str)} + {prepnp(po,loc)}
przesunąć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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)}
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)}
przeszkadzać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)}
przeszkadzać: imperf: subj{np(str)} + {np(dat)} + {prepncp(w,loc,żeby)}
przeszkadzać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przeszkadzać: imperf: subj{np(str)} + {prepncp(w,loc,że)}
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)}
przetrwać: perf: subj{np(str)} + obj{np(str)}
przeważać: imperf: subj{np(str)} + {np(inst)} + {np(str)}
przeważać: imperf: subj{np(str)} + {np(str)} + {xp(adl)}
przeważać: imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
przeważać: imperf: subj{np(str)} + {prepnp(u,gen)}
przeważać: imperf: subj{np(str)} + {prepnp(wśród,gen)}
przeważać: imperf: subj{np(str)} + {xp(locat)}
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)}
przewodniczyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
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)}
przewracać: imperf: subj{np(str)} + obj{np(str)} + {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)}
przewrócić: perf: subj{np(str)} + obj{np(str)} + {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)}
przeziębić: perf: subj{np(str)} + obj{np(str)}
przeziębić się: perf: subj{np(str)}
przeznaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
przeznaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przeznaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przeznaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przeżyć: perf: subj,controller{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)} + controlee{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)} + controlee{xp(mod)} + {cp(że)}
przeżywać: imperf: subj,controller{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + controlee{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)}
przybić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przybić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przybić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przybić: perf: subj{np(str)} + {preplexnp(z,inst,sg,'piątka',natr)}
przybijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przybijać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przybijać: imperf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(str,sg,'piątka',natr)}
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: subj{np(str)} + {np(dat)}
przybyć: perf: subj{np(str)} + {prepnp(na,acc)}
przybyć: perf: subj{np(str)} + {prepnp(z,inst)}
przybyć: perf: subj{np(str)} + {xp(adl)}
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,controlee{infp(_)} + controller{np(dat)}
przychodzić: imperf: subj,controlee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przychodzić: imperf: subj,controller{np(str)} + controlee{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)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
przychodzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
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)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyciągać się: imperf: subj{np(str)}
przyczepiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
przyczepiać się: imperf: subj{np(str)} + {or}
przyczepiać się: imperf: subj{np(str)} + {prepncp(do,gen,że)}
przyczepiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(że); prepncp(o,acc,że)}
przyczepić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyczepić się: perf: subj{np(str)} + {np(str)} + {or}
przyczepić się: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); prepncp(o,acc,ż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{cp(żeby)} + {np(dat)}
przydać się: perf: subj{infp(_)} + {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)}
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)}
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)}
przyjąć: perf: subj,controller{np(str)} + controlee{infp(ndk)}
przyjąć: perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(żeby)} + controlee{prepadjp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(żeby)} + controlee{prepnp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(że)} + controlee{prepadjp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(że)} + controlee{prepnp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controlee{prepadjp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controlee{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(ndk)}
przyjąć się: perf: subj{np(str)}
przyjechać: perf: subj,controller{np(str)} + controlee{infp(_)}
przyjechać: perf: subj{np(str)} + {np(inst)}
przyjechać: perf: subj{np(str)} + {prepnp(do,gen)}
przyjechać: perf: subj{np(str)} + {prepnp(na,acc)}
przyjechać: perf: subj{np(str)} + {prepnp(na,loc)}
przyjechać: perf: subj{np(str)} + {prepnp(od,gen)}
przyjechać: perf: subj{np(str)} + {prepnp(po,acc)}
przyjechać: perf: subj{np(str)} + {prepnp(za,inst)}
przyjechać: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przyjechać: perf: subj{np(str)} + {xp(perl)}
przyjeżdżać: imperf: subj{np(str)} + {np(inst)}
przyjeżdżać: imperf: subj{np(str)} + {prepnp(do,gen)}
przyjeżdżać: imperf: subj{np(str)} + {prepnp(na,acc)}
przyjeżdżać: imperf: subj{np(str)} + {prepnp(na,loc)}
przyjeżdżać: imperf: subj{np(str)} + {prepnp(od,gen)}
przyjeżdżać: imperf: subj{np(str)} + {prepnp(po,acc)}
przyjeżdżać: imperf: subj{np(str)} + {prepnp(za,inst)}
przyjeżdżać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przyjeżdżać: imperf: subj{np(str)} + {xp(perl)}
przyjmować: imperf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjmować: imperf: subj{np(str)} + obj,controller{cp(że)} + controlee{prepadjp(za,acc)}
przyjmować: imperf: subj{np(str)} + obj,controller{cp(że)} + controlee{prepnp(za,acc)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controlee{prepadjp(za,acc)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controlee{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(ndk)}
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)} + controlee{infp(_)}
przyjść: perf: {np(dat)} + {prepncp(na,acc,że)}
przyjść: perf: {np(dat)} + {prepnp(na,acc)}
przyjść: perf: subj,controlee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyjść: perf: subj,controlee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyjść: perf: subj,controller{np(str)} + controlee{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)} + {preplexnp(w,acc,pl,'odwiedziny',natr)}
przyjść: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
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)}
przykręcać: imperf: subj{np(str)} + {np(dat)} + {np(str)}
przykręcać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przykręcać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
przykręcić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przylegać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyłączać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
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)} + {prepnp(do,gen)}
przymocować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przynieść: perf: {np(str)} + {xp(adl)}
przynieść: perf: subj{lexnp(str,sg,'ślina',natr)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'język',natr)}
przynieść: perf: subj{np(str)} + {np(dat)} + {np(str)}
przynieść: perf: subj{np(str)} + {np(str)} + {xp(adl)}
przynieść: perf: subj{np(str)} + obj{np(str)} + {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(str)} + {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{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{np(str)} + {np(dat)} + {prepnp(do,gen)}
przypaść: perf: subj{np(str)} + {prepnp(na,acc)}
przypaść: perf: subj{np(str)} + {xp(temp)}
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)}
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}
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}
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}
przyrządzać: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
przyrządzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przysłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przysłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przysłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
przysługiwać: imperf: subj{np(str)} + {np(dat)}
przyspieszyć: perf: subj{np(str)} + obj{np(str)}
przystać: perf: subj{np(str)} + {prepnp(do,gen)}
przystać: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
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)}
przysyłać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przysyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przysyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przysyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
przysyłać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przysyłać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przyszyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przytoczyć: perf: subj{np(str)} + controller{cp(że)} + controlee{prepnp(jako,str)}
przytoczyć: perf: subj{np(str)} + controller{ncp(str,że)} + controlee{prepnp(jako,str)}
przytoczyć: perf: subj{np(str)} + controller{np(str)} + controlee{prepnp(jako,str)}
przytoczyć: perf: subj{np(str)} + {cp(int)}
przytoczyć: perf: subj{np(str)} + obj{np(str)} + {or}
przytoczyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przytoczyć się: perf: subj{np(str)} + {prepnp(do,gen)}
przytoczyć się: perf: subj{np(str)} + {xp(adl)}
przytulać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przytulać się: imperf: subj{np(str)} + {prepnp(do,gen)}
przytulać się: imperf: subj{np(str)} + {prepnp(u,gen)}
przytulić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytulić się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytulić się: perf: subj{np(str)} + {prepnp(u,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)}
przywieźć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
przywieźć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(abl)}
przywieźć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywieźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(adl)}
przywitać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
przywitać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przywitać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przywrócić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przywrócić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przywrócić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
przyzwyczaić się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
psuć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
psuć się: imperf: subj{np(str)} + {np(dat)}
psuć się: imperf: subj{np(str)} + {prepnp(od,gen)}
publikować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
publikować: imperf: subj{np(str)} + obj{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)}
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)}
puścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
puścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
puścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
puścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
puścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
puścić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
puścić się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
puścić się: perf: subj{np(str)} + {np(gen)}
puścić się: perf: subj{np(str)} + {prepnp(do,gen)}
puścić się: perf: subj{np(str)} + {prepnp(w,acc)}
puścić się: perf: subj{np(str)} + {xp(adl)}
pytać: imperf: subj{np(str)} + {np(gen)} + {or}
pytać: imperf: subj{np(str)} + {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)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
pytać się: imperf: subj{np(str)} + obj{np(gen)} + {or}
rabować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rabować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rabować: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
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)}
radzić: imperf: subj{np(str)} + {comprepnp(na temat)}
radzić: imperf: subj{np(str)} + controller{np(dat)} + controlee{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)}
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)}
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,inst)}
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)} + controlee{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)}
realizować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
realizować się: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
realizować się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
regulować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
regulować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
regulować się: imperf: subj{np(str)}
rejestrować: imperf: subj{np(str)} + {cp(int)}
rejestrować: imperf: subj{np(str)} + {cp(jak)}
rejestrować: imperf: subj{np(str)} + {cp(że)}
rejestrować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rejestrować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rejestrować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rejestrować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rejestrować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rejestrować się: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
rejestrować się: imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
rejestrować się: imperf: subj{np(str)} + {xp(locat)} + {refl}
reklamować: imperf: subj{np(str)} + {cp(że)} + {refl}
reklamować: imperf: subj{np(str)} + {np(dat)} + {refl}
reklamować: imperf: subj{np(str)} + {np(inst)} + {refl}
reklamować: imperf: subj{np(str)} + obj{ncp(str,że)}
reklamować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
reklamować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
reklamować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
reklamować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
reklamować: imperf: subj{np(str)} + {or} + {refl}
reklamować: imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
reklamować: imperf: subj{np(str)} + {xp(locat)} + {refl}
reperować: imperf: subj{np(str)} + {np(dat)} + {np(str)}
reperować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
reprezentować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
robić: imperf: subj,controller{np(str)} + controlee{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)} + controlee{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)} + {xp(mod)}
robić się: imperf: subj,controller{np(str)} + controlee{adjp(pred)}
robić się: imperf: subj,controller{np(str)} + controlee{np(inst)}
robić się: imperf: subj,controller{np(str)} + controlee{prepnp(na,acc)}
robić się: imperf: subj{np(str)} + {prepnp(z,gen)}
rodzić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
rodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rodzić się: imperf: subj,controller{np(str)} + controlee{adjp(inst)}
rodzić się: imperf: subj,controller{np(str)} + controlee{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)}
rosnąć: imperf: subj,controller{np(str)} + controlee{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(inst)} + {prepnp(na,acc)}
rozbić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rozbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rozbić się: perf: subj{np(str)} + {prepnp(na,acc)}
rozbić się: perf: subj{np(str)} + {prepnp(o,acc)}
rozbić się: perf: subj{np(str)} + {prepnp(w,acc)}
rozbić się: perf: subj{np(str)} + {xp(locat)}
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}
rozbudować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozbudować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozbudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rozbudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozbudować: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozbudować się: perf: subj{np(str)} + {xp(adl)}
rozbudować się: perf: subj{np(str)} + {xp(locat)}
rozchodzić: perf: subj{np(str)} + obj{np(str)}
rozchodzić się: imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozchodzić się: imperf: subj{np(str)} + {prepnp(z,inst)}
rozchodzić się: imperf: subj{np(str)} + {xp(adl)}
rozchodzić się: imperf: subj{np(str)} + {xp(perl)}
rozchodzić się: perf: subj{np(str)}
rozdawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozdawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
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}
rozegrać: perf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
rozegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozegrać: perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
rozegrać się: perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
rozejść się: perf: subj{cp(że)}
rozejść się: perf: subj{np(str)} + {prepnp(z,inst)}
rozejść się: perf: subj{np(str)} + {xp(adl)}
rozejść się: perf: subj{np(str)} + {xp(perl)}
rozerwać: perf: {np(dat)} + {np(str)}
rozerwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
rozerwać się: perf: subj{np(str)} + {xp(adl)}
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)}
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)}
rozgrywać: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
rozgrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozgrywać: imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
rozgrywać się: imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
rozkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozkładać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozkładać się: imperf: subj{np(str)} + {prepnp(między,acc)}
rozkładać się: imperf: subj{np(str)} + {prepnp(na,acc)}
rozkładać się: imperf: subj{np(str)} + {xp(locat)}
rozlać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); xp(adl); xp(locat)}
rozlać się: perf: subj{np(str)} + {prepnp(na,acc)}
rozlać się: perf: subj{np(str)} + {xp(adl); xp(locat)}
rozlegać się: imperf: subj{np(str)} + {xp(abl); xp(locat)}
rozlegać się: imperf: subj{or} + {xp(abl)}
rozlegać się: imperf: subj{or} + {xp(locat)}
rozlewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); xp(adl); xp(locat)}
rozlewać się: imperf: subj{np(str)} + {prepnp(w,acc)}
rozlewać się: imperf: subj{np(str)} + {xp(adl); xp(locat)}
rozliczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
rozliczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
rozliczać się: imperf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
rozliczać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
rozliczać się: imperf: subj{np(str)} + {prepnp(w,loc)}
rozliczać się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {prepnp(z,inst)}
rozliczać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
rozliczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
rozliczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
rozliczyć się: perf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
rozliczyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
rozliczyć się: perf: subj{np(str)} + {prepnp(w,loc)}
rozliczyć się: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)} + {prepnp(z,inst)}
rozliczyć się: perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
rozładować: perf: subj{ncp(str,że)} + obj{np(str)}
rozładować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
rozładowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozładowywać się: imperf: subj{np(str)} + {np(dat)}
rozłączać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozłączać się: imperf: subj{np(str)} + {or}
rozłączać się: imperf: subj{np(str)} + {prepnp(z,inst)}
rozłączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozłączyć się: perf: subj{np(str)} + {or}
rozłączyć się: perf: subj{np(str)} + {prepnp(z,inst)}
rozłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozłożyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozłożyć się: perf: subj{np(str)} + {prepnp(między,acc)}
rozłożyć się: perf: subj{np(str)} + {prepnp(na,acc)}
rozłożyć się: perf: subj{np(str)} + {xp(locat)}
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)}
rozmyślić się: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
rozpakować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpakować się: perf: subj{np(str)}
rozpakowywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozpakowywać się: imperf: subj{np(str)}
rozpatrywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
rozpatrywać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozpatrywać się: imperf: subj{np(str)} + {prepnp(w,loc)}
rozpatrzyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
rozpatrzyć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rozpatrzyć się: perf: subj{np(str)} + {prepnp(w,loc)}
rozpędzić: perf: subj{np(str)} + obj{np(str)}
rozpędzić się: perf: subj{np(str)} + {or}
rozpędzić się: perf: subj{np(str)} + {prepnp(do,gen)}
rozpocząć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{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)} + controlee{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)} + controlee{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)}
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)} + controlee{prepadjp(jako,str)} + {refl}
rozpoznać: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
rozpoznać: perf: subj{np(str)} + {cp(int); ncp(str,int)}
rozpoznać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
rozpoznać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
rozpoznawać: imperf: subj,controller{np(str)} + controlee{prepadjp(jako,str)}
rozpoznawać: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
rozpoznawać: imperf: subj{np(str)} + {cp(int); ncp(str,int)}
rozpoznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
rozpoznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
rozpoznawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozpoznawać: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozpoznawać: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
rozpoznawać się: imperf: subj{np(str)} + {prepnp(w,loc)}
rozstać się: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
rozstrzygać: imperf: subj{np(str)} + {cp(int)}
rozstrzygać: imperf: subj{np(str)} + {cp(że)}
rozstrzygać: imperf: subj{np(str)} + obj{np(str)}
rozstrzygać: imperf: subj{np(str)} + {prepncp(o,loc,int)}
rozstrzygać: imperf: subj{np(str)} + {prepncp(o,loc,że)}
rozstrzygać: imperf: subj{np(str)} + {prepnp(o,loc)}
rozstrzygać się: imperf: subj{np(str)}
rozstrzygnąć: perf: subj{np(str)} + {cp(int)}
rozstrzygnąć: perf: subj{np(str)} + obj{np(str)}
rozstrzygnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozstrzygnąć: perf: subj{np(str)} + {prepncp(o,loc,int)}
rozstrzygnąć: perf: subj{np(str)} + {prepncp(o,loc,że)}
rozstrzygnąć: perf: subj{np(str)} + {prepnp(o,loc)}
rozstrzygnąć się: perf: subj{np(str)}
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)}
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)} + controlee{prepadjp(jako,str)}
rozumieć: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
rozważać: imperf: subj{np(str)} + {cp(int)}
rozważać: imperf: subj{np(str)} + {ncp(str,int)}
rozważać: imperf: subj{np(str)} + {ncp(str,że)}
rozważać: imperf: subj{np(str)} + obj{np(str)}
rozważyć: perf: subj{np(str)} + {cp(int)}
rozważyć: perf: subj{np(str)} + obj{np(str)}
rozwiązać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
rozwiązać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwiązać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozwiązać się: perf: subj,controller{np(str)} + controlee{xp(mod)}
rozwiązać się: perf: subj{np(str)} + {np(str)}
rozwiązywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
rozwiązywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwiązywać się: imperf: subj,controller{np(str)} + controlee{xp(mod)}
rozwiązywać się: imperf: subj{np(str)} + {np(inst)}
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)}
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,loc)}
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)}
równać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
równać się: imperf: subj,controller{np(str)} + controlee{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(inst)}
rujnować się: imperf: subj{np(str)} + {prepnp(na,acc)}
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)}
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)} + {ncp(inst,że)}
ryzykować: imperf: subj{np(str)} + {ncp(str,że)}
ryzykować: imperf: subj{np(str)} + {np(inst)}
ryzykować: imperf: subj{np(str)} + obj{np(str)}
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)} + controlee{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)}
rzucać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rzucać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rzucać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rzucać się: imperf: subj,controller{np(str)} + controlee{infp(_)}
rzucać się: imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: imperf: subj{np(str); 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)}
rzucić: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rzucić: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rzucić: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rzucić się: perf: subj,controller{np(str)} + controlee{infp(_)}
rzucić się: perf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: perf: subj{np(str); 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)}
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)}
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)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
schodzić: perf: subj{np(str)} + obj{np(str)}
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)}
schować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
schować: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
schować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
schować: perf: subj{np(str)} + {xp(locat)} + {refl}
schować się: perf: subj{np(str)} + {prepnp(przed,inst)}
schować się: perf: subj{np(str)} + {prepnp(przy,loc)}
schować się: perf: subj{np(str)} + {prepnp(z,inst)}
schować się: perf: subj{np(str)} + {xp(locat)}
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)}
sędziować: imperf: subj{np(str)} + {np(dat)}
sędziować: imperf: subj{np(str)} + obj{np(str)}
sędziować: imperf: subj{np(str)} + {prepnp(w,loc)}
sędziować: imperf: subj{np(str)} + {xp(locat)}
sfinansować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
sfinansować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sformułować: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
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)}
sięgać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
sięgać: imperf: subj{np(str)} + {np(gen)}
sięgać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)} + {xp(adl)}
sięgnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
sięgnąć: perf: subj{np(str)} + {np(gen)}
sięgnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)} + {xp(adl)}
skakać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skakać: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
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)}
skakać: imperf: subj{np(str)} + {prepnp(przed,inst)}
skaleczyć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
skaleczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
skaleczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
skaleczyć: perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
skarżyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
skarżyć: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
skarżyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepncp(o,acc,że)}
skarżyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
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)} + {cp(int); cp(że)}
skarżyć się: imperf: subj{np(str)} + {np(dat)} + {or}
skarżyć się: imperf: subj{np(str)} + {np(dat)} + {prepncp(na,acc,int)}
skarżyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
skarżyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepncp(na,acc,że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
skarżyć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
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)}
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ć 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łonić: perf: subj{np(str)} + {np(inst)} + {np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
skłonić: perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
skłonić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
skłonić się: perf: subj{np(str)} + {np(dat)}
skłonić się: perf: subj{np(str)} + {prepncp(ku,dat,że)}
skłonić się: perf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
skoczyć: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
skoczyć: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
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)}
skonać: perf: subj{np(str)}
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)}
skończyć: perf: subj,controller{np(str)} + controlee{infp(ndk)}
skończyć: perf: subj,controller{np(str)} + controlee{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)}
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)}
skraść: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
skraść: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
skręcać: imperf: {np(str)} + {prepnp(z,gen)}
skręcać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
skręcać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
skręcać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skręcać: imperf: subj{np(str)} + {xp(adl)}
skręcać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skręcać się: imperf: subj{np(str)} + {prepnp(od,gen)}
skręcać się: imperf: subj{np(str)} + {prepnp(z,gen)}
skręcić: perf: obj{np(str)} + {prepnp(z,gen)}
skręcić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
skręcić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
skręcić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
skręcić: perf: subj{np(str)} + {xp(adl)}
skręcić się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
skręcić się: perf: subj{np(str)} + {prepnp(od,gen)}
skręcić się: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
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ć 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)}
słuchać: imperf: subj{np(str)} + {cp(int)}
słuchać: imperf: subj{np(str)} + {cp(że)}
słuchać: imperf: subj{np(str)} + {ncp(loc,jak)}
słuchać: imperf: subj{np(str)} + {np(gen); prepnp(o,loc); prepncp(o,loc,int); 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)} + controlee{prepnp(jako,str)} + {np(dat)}
służyć: imperf: subj,controller{np(str)} + controlee{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ł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)} + controlee{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ć się: imperf: subj{np(str)}
smażyć: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
smażyć: imperf: subj{np(str)} + obj{np(str)} + {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)}
solić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
solić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
spać: imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
spać: imperf: subj{np(str)} + {prepnp(z,inst)}
spać: imperf: subj{np(str)} + {xp(locat)}
spadać: imperf: subj,controller{np(str)} + controlee{xp(mod)}
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(abl)}
spadać: imperf: subj{np(str)} + {prepnp(na,loc)}
spadać: imperf: subj{np(str)} + {xp(adl)}
spalić: perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
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)}
spalić się: perf: subj{np(str)} + {advp(misc)}
spalić się: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
spełniać: imperf: subj{np(str)} + obj{np(str)}
spełniać się: imperf: subj,controller{np(str)} + controlee{prepnp(w,loc)}
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)} + controlee{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,controller{np(str)} + obj{np(str)} + controlee{xp(mod)}
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)} + {xp(locat)}
spieszyć: imperf: subj,controller{np(str)} + controlee{infp(_)}
spieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
spieszyć: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); xp(adl)}
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)} + controlee{infp(_)}
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)}
spisać: perf: subj{np(str)} + {ncp(str,że)}
spisać: perf: subj{np(str)} + obj{np(str)} + {or}
spisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,inst)}
spisać się: perf: subj{np(str)} + {advp(misc)}
spisać się: perf: subj{np(str)} + {prepnp(na,acc)}
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)}
spoczywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
spoczywać: imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
spodobać się: perf: {np(dat)} + {xp(locat)}
spodobać się: perf: subj{cp(gdy)} + {np(dat)}
spodobać się: perf: subj{cp(jak); ncp(str,jak)} + {np(dat)}
spodobać się: perf: subj{cp(że); ncp(str,że)} + {np(dat)}
spodziewać się: imperf: subj,controller{np(str)} + controlee{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)} + controlee{xp(mod)}
spoglądać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spoglądać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
spoglądać: imperf: subj{np(str)} + {prepnp(po,dat)}
spojrzeć: perf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{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ć się: perf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{xp(mod)}
spojrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spojrzeć się: perf: subj{np(str)} + {prepnp(na,acc)}
sporządzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sporządzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
spotkać: perf: subj{ncp(str,że)} + obj{np(str)} + {prepnp(za,acc)}
spotkać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
spotkać się: perf: subj{np(str)} + {prepnp(z,inst)}
spotykać: imperf: subj{ncp(str,że)} + obj{np(str)} + {prepnp(za,acc)}
spotykać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
spotykać się: imperf: subj{np(str)} + {prepnp(z,inst)}
spowodować: perf: subj{np(str)} + {np(str); cp(że); ncp(str,że)}
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(acc)} + {prepnp(do,gen); prepnp(na,acc)}
spóźnić się: perf: subj{np(str)} + {np(acc)} + {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)} + controlee{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)} + controlee{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)} + {np(inst)}
sprawiać: imperf: subj{np(str); ncp(str,że)} + {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)} + {prepnp(za,acc); prepncp(za,acc,że)}
sprawiać się: imperf: subj,controller{np(str)} + controlee{xp(mod)}
sprawić: perf: subj{np(str)} + {cp(żeby)}
sprawić: perf: subj{np(str); cp(że); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprawić: perf: subj{np(str); ncp(str,że)} + {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)} + {prepnp(za,acc); prepncp(za,acc,że)}
sprawić się: perf: subj,controller{np(str)} + controlee{xp(mod)}
sprawować: imperf: subj{np(str)} + obj{np(str)}
sprawować się: imperf: subj,controller{np(str)} + controlee{xp(mod)}
sprowadzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
sprowadzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(z,gen)}
sprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {or}
sprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
sprowadzać się: imperf: subj{np(str)} + {prepncp(do,gen,int)}
sprowadzać się: imperf: subj{np(str)} + {prepncp(do,gen,że)}
sprowadzać się: imperf: subj{np(str)} + {prepncp(do,gen,żeby)}
sprowadzać się: imperf: subj{np(str)} + {prepnp(do,gen)}
sprowadzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sprowadzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(z,gen)}
sprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {or}
sprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
sprowadzić się: perf: subj{np(str)} + {prepncp(do,gen,int)}
sprowadzić się: perf: subj{np(str)} + {prepncp(do,gen,że)}
sprowadzić się: perf: subj{np(str)} + {prepncp(do,gen,żeby)}
sprowadzić się: perf: subj{np(str)} + {prepnp(do,gen)}
spróbować: perf: subj,controller{np(str)} + controlee{infp(_)}
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ć się: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
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)}
sprzedać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
sprzedać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sprzedać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
sprzedać się: perf: subj{np(str)} + {np(dat)}
sprzedawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
sprzedawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
sprzedawać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
sprzedawać się: imperf: subj{np(str)} + {np(dat)}
sprzyjać: imperf: subj{np(str)} + {ncp(dat,że)}
sprzyjać: imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
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)}
spytać: perf: subj{np(str)} + {np(gen)} + {or}
spytać: perf: subj{np(str)} + {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)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
spytać się: perf: subj{np(str)} + obj{np(gen)} + {or}
stać: imperf: {np(dat)} + {np(gen)}
stać: imperf: {np(str)} + {cp(żeby)}
stać: imperf: {np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
stać: imperf: {prepncp(na,loc,że)}
stać: imperf: subj,controller{np(str)} + controlee{xp(mod)}
stać: imperf: subj{cp(żeby)} + {xp(locat)}
stać: imperf: subj{cp(że)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stać: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: imperf: subj{cp(że)} + {xp(locat)}
stać: imperf: subj{ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'ość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stać: imperf: subj{nonch} + {cp(że)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stać: imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stać: imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {preplexnp(na,loc,sg,'przeszkoda',natr)}
stać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'droga',natr)}
stać: imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
stać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
stać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
stać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)} + {fixed('dęba')}
stać: imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {preplexnp(u,gen,pl,'podstawa',natr)}
stać: imperf: subj{np(str)} + {np(inst)}
stać: imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',atr)}
stać: imperf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',ratr)}
stać: imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(w,loc,sg,'sprzeczność',atr)}
stać: imperf: subj{np(str)} + {prepnp(między,inst)}
stać: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
stać: imperf: subj{np(str)} + {prepnp(o,acc)}
stać: imperf: subj{np(str)} + {prepnp(po,acc)}
stać: imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {lexnp(inst,sg,'mur',natr)}
stać: imperf: subj{np(str)} + {prepnp(przed,inst)}
stać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,sg,'otwór',natr)}
stać: imperf: subj{np(str)} + {prepnp(przy,loc)}
stać: imperf: subj{np(str)} + {prepnp(w,loc)}
stać: imperf: subj{np(str)} + {prepnp(wobec,gen)}
stać: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,że); prepncp(za,inst,żeby)}
stać: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)} + {lexnp(inst,sg,'mur',natr)}
stać: imperf: subj{np(str)} + {prepnp(z,gen)} + {advp(misc)}
stać: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)} + {preplexnp(w,loc,sg,'sprzeczność',atr)}
stać: imperf: subj{or} + {xp(locat)}
stać: imperf: subj{prepnp(o,loc); prepncp(o,loc,że)} + {xp(locat)}
stać się: perf: {cp(że)} + {advp(misc)}
stać się: perf: {np(dat)} + {advp(misc)}
stać się: perf: subj,controller{cp(int)} + controlee{adjp(pred)}
stać się: perf: subj,controller{cp(int)} + controlee{np(inst)}
stać się: perf: subj,controller{cp(żeby)} + controlee{adjp(pred)}
stać się: perf: subj,controller{cp(żeby)} + controlee{np(inst)}
stać się: perf: subj,controller{cp(że)} + controlee{adjp(pred)}
stać się: perf: subj,controller{cp(że)} + controlee{np(inst)}
stać się: perf: subj,controller{ncp(str,int)} + controlee{adjp(pred)}
stać się: perf: subj,controller{ncp(str,int)} + controlee{np(inst)}
stać się: perf: subj,controller{ncp(str,żeby)} + controlee{np(inst)}
stać się: perf: subj,controller{ncp(str,że)} + controlee{adjp(pred)}
stać się: perf: subj,controller{ncp(str,że)} + controlee{np(inst)}
stać się: perf: subj,controller{np(str)} + controlee{adjp(pred)} + {np(dat)} + {prepadjp(z,gen)}
stać się: perf: subj,controller{np(str)} + controlee{np(inst)} + {np(dat)} + {prepnp(z,gen)}
stać się: perf: subj,controller{np(str); ncp(str,żeby)} + controlee{adjp(pred)}
stać się: perf: subj{cp(że)}
stać się: perf: subj{nonch} + {np(dat)} + {prepnp(z,inst)}
stanąć: perf: {np(dat)} + {np(gen)}
stanąć: perf: {prepadjp(na,loc)}
stanąć: perf: {prepnp(na,loc); prepncp(na,loc,że); prepncp(na,loc,żeby)}
stanąć: perf: subj{lexnp(str,pl,'oko',natr)} + {np(dat)} + {preplexnp(w,acc,sg,'słup',natr)}
stanąć: perf: subj{lexnp(str,pl,'świeczka',natr)} + {np(dat)} + {preplexnp(w,loc,pl,'oko',natr)}
stanąć: perf: subj{lexnp(str,sg,'język',natr)} + {np(dat)} + {lexnp(inst,sg,'kołek',natr)}
stanąć: perf: subj{np(str)} + {lexnp(gen,sg,'słupek',natr)}
stanąć: perf: subj{np(str)} + {lexnp(inst,sg,'sztorc',natr)}
stanąć: perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stanąć: perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
stanąć: perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stanąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
stanąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
stanąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
stanąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)} + {fixed('dęba')}
stanąć: perf: subj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',atr)}
stanąć: perf: subj{np(str)} + {preplexnp(w,acc,pl,'szranki',atr)}
stanąć: perf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',ratr)}
stanąć: perf: subj{np(str)} + {prepnp(do,gen)}
stanąć: perf: subj{np(str)} + {prepnp(między,inst)}
stanąć: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
stanąć: perf: subj{np(str)} + {prepnp(przeciw,dat)} + {lexnp(inst,sg,'mur',natr)}
stanąć: perf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,sg,'otwór',natr)}
stanąć: perf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że)}
stanąć: perf: subj{np(str)} + {prepnp(przy,loc)}
stanąć: perf: subj{np(str)} + {prepnp(w,loc)}
stanąć: perf: subj{np(str)} + {prepnp(wobec,gen)}
stanąć: perf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(inst,sg,'mur',natr)}
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)} + controlee{prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby); infp(_)}
startować: imperf: subj{np(str)} + {prepnp(do,gen)}
startować: imperf: subj{np(str)} + {prepnp(w,loc)}
startować: imperf: subj{np(str)} + {xp(abl)}
stawać: imperf: {np(dat)} + {np(gen)}
stawać: imperf: {prepadjp(na,loc)}
stawać: imperf: {prepnp(na,loc); prepncp(na,loc,że)}
stawać: imperf: subj{lexnp(str,pl,'oko',natr)} + {np(dat)} + {preplexnp(w,acc,sg,'słup',natr)}
stawać: imperf: subj{lexnp(str,pl,'świeczka',natr)} + {np(dat)} + {preplexnp(w,loc,pl,'oko',natr)}
stawać: imperf: subj{lexnp(str,sg,'język',natr)} + {np(dat)} + {lexnp(inst,sg,'kołek',natr)}
stawać: imperf: subj{np(str)} + {lexnp(gen,sg,'słupek',natr)}
stawać: imperf: subj{np(str)} + {lexnp(inst,sg,'sztorc',natr)}
stawać: imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'kość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stawać: imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
stawać: imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ość',natr)} + {preplexnp(w,loc,sg,'gardło',natr)}
stawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
stawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
stawać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
stawać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)} + {fixed('dęba')}
stawać: imperf: subj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',atr)}
stawać: imperf: subj{np(str)} + {preplexnp(w,acc,pl,'szranki',atr)}
stawać: imperf: subj{np(str)} + {preplexnp(w,loc,sg,'oblicze',ratr)}
stawać: imperf: subj{np(str)} + {prepnp(do,gen)}
stawać: imperf: subj{np(str)} + {prepnp(między,inst)}
stawać: imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {lexnp(inst,sg,'mur',natr)}
stawać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,sg,'otwór',natr)}
stawać: imperf: subj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
stawać: imperf: subj{np(str)} + {prepnp(przy,loc)}
stawać: imperf: subj{np(str)} + {prepnp(w,loc)}
stawać: imperf: subj{np(str)} + {prepnp(wobec,gen)}
stawać: imperf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(inst,sg,'mur',natr)}
stawać się: imperf: {advp(misc)}
stawać się: imperf: {np(dat)} + {advp(misc)}
stawać się: imperf: subj,controller{cp(int)} + controlee{adjp(pred)}
stawać się: imperf: subj,controller{cp(int)} + controlee{np(inst)}
stawać się: imperf: subj,controller{cp(żeby)} + controlee{adjp(pred)}
stawać się: imperf: subj,controller{cp(żeby)} + controlee{np(inst)}
stawać się: imperf: subj,controller{cp(że)} + controlee{adjp(pred)}
stawać się: imperf: subj,controller{cp(że)} + controlee{np(inst)}
stawać się: imperf: subj,controller{ncp(str,int)} + controlee{adjp(pred)}
stawać się: imperf: subj,controller{ncp(str,int)} + controlee{np(inst)}
stawać się: imperf: subj,controller{ncp(str,żeby)} + controlee{adjp(pred)}
stawać się: imperf: subj,controller{ncp(str,żeby)} + controlee{np(inst)}
stawać się: imperf: subj,controller{ncp(str,że)} + controlee{adjp(pred)}
stawać się: imperf: subj,controller{ncp(str,że)} + controlee{np(inst)}
stawać się: imperf: subj,controller{np(str)} + controlee{adjp(pred)} + {prepadjp(z,gen)}
stawać się: imperf: subj,controller{np(str)} + controlee{np(inst)} + {prepnp(z,gen)}
stawać się: imperf: subj{nonch} + {prepnp(z,inst)}
stawać się: imperf: subj{np(str)} + {np(dat)}
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(wobec,gen)}
stawiać się: imperf: subj{np(str)} + {xp(adl)}
stawiać się: imperf: subj{np(str)} + {xp(locat)}
stawić: perf: subj{np(str)} + {np(dat)} + {np(str)}
stawić się: perf: subj,controller{np(str)} + controlee{xp(mod)}
stawić się: perf: subj{np(str)} + {np(dat)}
stawić się: perf: subj{np(str)} + {prepnp(do,gen)}
stawić się: perf: subj{np(str)} + {prepnp(na,acc)}
stawić się: perf: subj{np(str)} + {xp(adl)}
stawić się: perf: subj{np(str)} + {xp(locat)}
stemplować: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
stemplować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
stemplować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)}
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}
straszyć: imperf: subj{np(str)} + {cp(że)} + {refl}
straszyć: imperf: subj{np(str)} + {np(inst)} + {refl}
straszyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst); cp(że)}
straszyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
straszyć: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
straszyć: imperf: subj{np(str)} + {or}
strzec: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
strzec: imperf: subj{np(str)} + obj{np(str)} + {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)}
strzyc: imperf: subj{np(str)} + {lexnp(inst,pl,'ucho',natr)}
strzyc: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
strzyc: imperf: subj{np(str)} + {refl}
strzyc się: imperf: subj{np(str)} + {prepnp(u,gen)}
strzyc się: imperf: subj{np(str)} + {xp(locat)}
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)}
stukać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
stukać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
stukać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
stukać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
stukać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
stukać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
stukać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
stukać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
stuknąć: perf: subj{np(str)} + {np(dat)}
stuknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
stuknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
stuknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
stuknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
stuknąć się: perf: subj{np(str)} + {np(inst)}
stwarzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
stwarzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
stwarzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
stwarzać się: imperf: subj{np(str)}
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)}
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ć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
stworzyć się: perf: subj{np(str)} + {prepnp(z,gen)}
stykać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
stykać się: imperf: subj{np(str)} + {prepnp(z,inst)}
sugerować: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
sugerować: imperf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
sugerować: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
sugerować: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
sugerować: imperf: subj{np(str)} + {np(dat)} + {ncp(str,że)}
sugerować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
sugerować: imperf: subj{np(str)} + {or}
sugerować się: imperf: subj{np(str)} + {cp(że)}
sugerować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
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)} + {prepnp(przy,loc)}
swędzić: imperf: {np(str)} + {xp(locat)}
swędzić: imperf: subj{cp(żeby)} + {np(str)}
swędzić: imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
szacować: imperf: subj{np(str)} + {cp(że)}
szacować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szanować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
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}
szkoda: imperf: controller{np(dat)} + controlee{infp(_)}
szkoda: imperf: {np(dat)} + {cp(gdy)}
szkoda: imperf: {np(dat)} + {cp(jak)}
szkoda: imperf: {np(dat)} + {cp(kiedy)}
szkoda: imperf: {np(dat)} + {cp(że)}
szkoda: imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
szkoda: imperf: {np(dat)} + {np(gen); ncp(gen,że)}
szkoda: imperf: {np(dat)} + {np(gen)} + {prepnp(dla,gen)}
szkoda: imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen)}
szkoda: imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
szkodzić: imperf: subj{np(str)} + {ncp(dat,żeby)}
szkodzić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
szkodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
szukać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
szukać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
szukać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
szukać: imperf: subj{np(str)} + {xp(locat)} + {refl}
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)} + controlee{infp(_)}
szykować się: imperf: subj{np(str)}
ściągać: imperf: subj{np(str)} + {infp(_)} + {xp(adl)}
ś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)} + 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)}
ś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: subj{np(str)} + {np(inst)} + {refl}
ściskać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
ściskać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ściskać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ściskać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ściskać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
ś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)}
ścisnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ścisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ścisnąć: perf: subj{np(str)} + obj{np(str)} + {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)}
śmiać się: imperf: subj{lexnp(str,_,'oko',natr)} + {np(dat)} + {prepnp(do,gen)}
śmiać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ś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,że)}
śmieć: imperf: subj,controller{np(str)} + controlee{infp(_)}
ś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)} + controlee{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)} + controlee{infp(_)}
śpieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
śpieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
śpieszyć: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); xp(adl)}
śpieszyć: imperf: subj{np(str)} + {prepnp(o,acc)}
śpieszyć się: imperf: {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
śpieszyć się: imperf: subj,controller{np(str)} + controlee{infp(_)}
ś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,controller{np(str)} + {prepnp(o,loc); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)} + {advp(misc)}
ś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)} + {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)}
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)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
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,że); prepncp(za,inst,żeby)}
tęsknić się: imperf: {np(dat)} + {prepnp(do,gen)}
tęsknić się: imperf: {np(dat)} + {prepnp(za,inst)}
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(inst)} + {prepnp(po,loc)}
tłuc: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'miazga',atr)}
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{ncp(str,że)} + {np(str)}
tłumaczyć: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
tłumaczyć: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
tłumaczyć: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
tłumaczyć: imperf: subj{np(str)} + {np(dat)} + {or}
tłumaczyć: imperf: subj{np(str)} + obj{np(str)} + {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)} + {prepadjp(na,acc)} + {prepadjp(z,gen)}
tłumaczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
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)}
to: imperf: subj,controller{cp(żeby)} + controlee{advp(misc)}
to: imperf: subj,controller{cp(żeby)} + controlee{np(nom)}
to: imperf: subj,controller{cp(że)} + controlee{advp(misc)}
to: imperf: subj,controller{cp(że)} + controlee{np(nom)}
to: imperf: subj,controller{infp(_)} + controlee{infp(_)}
to: imperf: subj,controller{infp(_)} + controlee{np(nom)}
to: imperf: subj,controller{np(str); ncp(str,że)} + controlee{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)} + controlee{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)}
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)}
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{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{np(str)} + {np(dat)}
traktować: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
traktować: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {refl}
traktować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
traktować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
traktować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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(od,gen)} + {prepnp(z,inst)}
trenować: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
trenować się: imperf: subj{np(str)} + {prepnp(w,loc)}
trwać: imperf: subj,controller{np(str)} + controlee{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)}
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)} + controlee{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: controller{np(dat)} + controlee{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)}
trzeba: imperf: {xp(mod)}
trzepać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trzepać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
trzepać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
trzepać: imperf: subj{np(str)} + {prepnp(o,loc)}
trzepać się: imperf: subj{np(str)}
trzepnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
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)}
trzepnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzepnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzepnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trzymać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
trzymać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
trzymać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
trzymać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
trzymać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
trzymać się: imperf: subj{np(str)} + {np(gen)} + {np(inst)}
trzymać się: imperf: subj{np(str)} + {prepnp(na,loc)}
trzymać się: imperf: subj{np(str)} + {prepnp(za,acc)}
trzymać się: imperf: subj{np(str)} + {prepnp(z,inst)}
trzymać się: imperf: subj{np(str)} + {xp(adl)}
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)} + {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(do,gen)}
ubezpieczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepnp(od,gen)}
ubezpieczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ubezpieczać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ubezpieczać się: imperf: subj{np(str)} + {comprepnp(z powodu)}
ubezpieczać się: imperf: subj{np(str)} + {cp(żeby)}
ubezpieczać się: imperf: subj{np(str)} + {prepncp(po,acc,żeby)}
ubezpieczać się: imperf: subj{np(str)} + {prepnp(na,gen); prepnp(od,gen)}
ubiegać: imperf: subj{np(str)} + obj{np(str)} + {or}
ubiegać się: imperf: subj{np(str)} + {cp(żeby); prepncp(o,acc,żeby)}
ubiegać się: imperf: subj{np(str)} + {prepnp(o,acc)}
ubierać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{xp(mod)}
ubierać się: imperf: subj{np(str)} + {prepnp(u,gen)}
ubierać się: imperf: subj{np(str)} + {xp(locat)}
ubrać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{xp(mod)}
ubrać się: perf: subj{np(str)} + {prepnp(u,gen)}
ubrać się: perf: subj{np(str)} + {xp(locat)}
uchodzić: imperf: controller{np(dat)} + controlee{infp(_)}
uchodzić: imperf: subj,controller{infp(_)} + controlee{prepnp(za,acc)}
uchodzić: imperf: subj,controller{np(str)} + controlee{prepadjp(za,acc)}
uchodzić: imperf: subj,controller{np(str)} + controlee{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}
uchylić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uchylić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uchylić się: perf: subj{np(str)} + {prepnp(od,gen)}
uchylić się: perf: subj{np(str)} + {prepnp(przed,inst)}
uchylić się: perf: subj{np(str)} + {xp(adl)}
uciec: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
uciec: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
uciec: perf: subj{np(str)} + {prepnp(do,gen)}
uciec: perf: subj{np(str)} + {prepnp(od,gen)}
uciec: perf: subj{np(str)} + {prepnp(przed,inst)}
uciec: perf: subj{np(str)} + {prepnp(z,inst)}
uciec się: perf: subj{np(str)} + {prepnp(do,gen)}
uciec się: perf: subj{np(str)} + {prepnp(pod,acc)}
uciekać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
uciekać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
uciekać: imperf: subj{np(str)} + {prepnp(do,gen)}
uciekać: imperf: subj{np(str)} + {prepnp(od,gen)}
uciekać: imperf: subj{np(str)} + {prepnp(przed,inst)}
uciekać: imperf: subj{np(str)} + {prepnp(z,inst)}
uciekać się: imperf: subj{np(str)} + {prepnp(do,gen)}
uciekać się: imperf: subj{np(str)} + {prepnp(pod,acc)}
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)}
uczestniczyć: imperf: subj{np(str)} + {prepnp(w,loc)}
uczyć: imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
uczyć: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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(ndk)}
uczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uczyć się: imperf: subj,controller{np(str)} + controlee{np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(ndk)} + {prepnp(od,gen); prepnp(z,gen); prepnp(z,inst)}
uczyć się: imperf: subj{np(str)} + {advp(misc)}
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)}
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)} + controlee{adjp(inst)}
uczynić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{adjp(pred)}
udać: perf: subj,controller{np(str)} + controlee{adjp(str)}
udać: perf: subj,controller{np(str)} + controlee{np(str)}
udać: perf: subj{np(str)} + {cp(że)}
udać: perf: subj{np(str)} + obj{np(str)}
udać się: perf: controller{np(dat)} + controlee{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)}
udawać: imperf: subj,controller{np(str)} + controlee{adjp(str)}
udawać: imperf: subj,controller{np(str)} + controlee{np(str)}
udawać: imperf: subj{np(str)} + {cp(że)}
udawać: imperf: subj{np(str)} + obj{np(str)}
udawać się: imperf: controller{np(dat)} + controlee{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,loc)} + {prepnp(w,acc)}
udostępniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepnp(pod,acc)}
udostępniać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
udostępnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
udostępnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
udostępnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
udostępnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
udostępnić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
udzielać: imperf: subj{np(str)} + obj{np(gen)} + {np(dat)}
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)} + {np(dat)}
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)}
ufundować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ufundować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ujawniać: imperf: subj{np(str)} + obj{cp(int); cp(że)}
ujawniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ujawniać się: imperf: subj{np(str)} + {np(dat)}
ujawniać się: imperf: subj{np(str)} + {xp(locat)}
ujawniać się: imperf: subj{np(str)} + {xp(temp)}
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)} + controlee{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)} + controlee{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}
ujmować: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{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)} + controlee{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)} + controlee{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)} + controlee{xp(mod)}
ukazywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ukazywać się: imperf: subj,controller{np(str)} + controlee{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)} + controlee{infp(ndk)}
układać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
układać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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(z,inst)} + {xp(mod)}
układać się: imperf: subj,controller{np(str)} + controlee{infp(_)}
układać się: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {np(dat)}
układać się: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {prepnp(na,loc)}
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)} + {prepnp(o,acc)} + {prepnp(z,inst)}
układać się: imperf: subj{np(str)} + {prepnp(pod,acc)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
układać się: imperf: subj{np(str)} + {xp(locat)}
ukłonić się: perf: subj,controller{np(str)} + controlee{xp(mod)} + {np(dat)} + {prepnp(od,gen)}
ukłonić się: perf: subj,controller{np(str)} + controlee{xp(mod)} + {xp(abl)}
ukłonić się: perf: subj{np(str)} + {np(dat)} + {np(inst)}
ukończyć: perf: subj{np(str)} + obj{np(str)}
ukraść: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ukryć: perf: subj{np(str)} + {cp(int)}
ukryć: perf: subj{np(str)} + {cp(że)}
ukryć: perf: subj{np(str)} + {ncp(str,że)}
ukryć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
ukryć: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
ukryć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
ukryć się: perf: subj{np(str)} + {xp(locat)}
ukrywać: imperf: subj{np(str)} + {cp(int)}
ukrywać: imperf: subj{np(str)} + {ncp(str,że)}
ukrywać: imperf: subj{np(str)} + obj{np(str)} + {fixed('w sobie')}
ukrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
ukrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ukrywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ukrywać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
ukrywać się: imperf: subj{np(str)} + {prepnp(pod,inst)}
ukrywać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
ukrywać się: imperf: subj{np(str)} + {xp(locat)}
ulec: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulegać: imperf: subj{np(str)} + {ncp(dat,że)}
ulegać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulepszać: imperf: subj{np(str)} + obj{np(str)}
ulepszyć: perf: subj{np(str)} + obj{np(str)}
ulokować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,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)}
ułatwiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ułatwić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ułożyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{infp(ndk)}
ułożyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
ułożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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(z,inst)} + {xp(mod)}
ułożyć się: perf: subj,controller{np(str)} + controlee{infp(_)}
ułożyć się: perf: subj,controller{np(str)} + controlee{xp(mod)} + {np(dat)}
ułożyć się: perf: subj,controller{np(str)} + controlee{xp(mod)} + {prepnp(na,loc)}
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)} + {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)}
umacniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
umacniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umacniać się: imperf: subj{np(str)} + {prepnp(w,loc)}
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)} + controlee{np(str); infp(_)}
umieć: imperf: subj{np(str)} + {prepadjp(po,postp)}
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(na,loc)}
umieszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
umieszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umieszczać się: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
umieścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
umieścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
umieścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umieścić się: perf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
umocnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
umocnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
umocnić się: perf: subj{np(str)} + {np(inst)}
umocnić się: perf: subj{np(str)} + {prepnp(w,loc)}
umorzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
umożliwiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
umożliwić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
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)} + {np(str)} + {prepnp(od,gen)}
umywać się: imperf: subj{np(str)} + {prepnp(do,gen)}
uniemożliwiać: imperf: subj{np(str)} + obj{cp(żeby); ncp(str,żeby)}
uniemożliwiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
unieść: perf: subj{np(str)} + {np(str)} + {or}
unieść: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
unieść się: perf: subj{np(str)} + {np(inst)}
unieść się: perf: subj{np(str)} + {or}
unieść się: perf: subj{np(str)} + {prepnp(nad,acc)}
unieść się: perf: subj{np(str)} + {prepnp(nad,inst)}
unieść się: perf: subj{np(str)} + {xp(adl)}
unieść się: perf: subj{np(str)} + {xp(locat)}
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}
unikać: imperf: subj{np(str)} + obj{np(gen)}
uniknąć: perf: subj{np(str)} + obj{np(gen)}
unosić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
unosić się: imperf: subj{np(str)} + {np(inst)}
unosić się: imperf: subj{np(str)} + {prepnp(nad,inst)}
unosić się: imperf: subj{np(str)} + {xp(locat)}
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)}
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)}
upchać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
upchać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
upchać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upchać: perf: subj{np(str)} + {xp(locat)} + {refl}
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)} + controlee{xp(mod)}
upić się: perf: subj{np(str)} + {np(inst)}
upierać się: imperf: subj,controller{np(str)} + controlee{infp(_)}
upierać się: imperf: subj{np(str)} + {cp(że)}
upierać się: imperf: subj{np(str)} + {cp(żeby)}
upierać się: imperf: subj{np(str)} + {prepncp(przy,loc,żeby)}
upierać się: imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że)} + {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)} + controlee{xp(mod)}
upijać się: imperf: subj{np(str)} + {np(inst)}
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)}
uporządkować: perf: subj{np(str)} + obj{np(str)}
uporządkować się: perf: subj{np(str)}
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)}
uprawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uprawić: perf: subj{np(str)} + obj{np(str)}
uprzeć się: perf: subj,controller{np(str)} + controlee{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)}
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)}
uratować: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(przed,inst)}
uratować: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
uratować: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
uratować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uratować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uratować: perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
uratować: perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
uratować: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)}
uregulować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uregulować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uregulować się: perf: subj{np(str)}
urodzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
urodzić się: perf: subj,controller{np(str)} + controlee{adjp(pred)} + {np(dat)}
urodzić się: perf: subj,controller{np(str)} + controlee{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)}
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)}
urwać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
urwać: perf: subj{np(str)} + {or}
urwać się: perf: subj{np(str)} + {np(dat)}
urwać się: perf: subj{np(str)} + {xp(abl)}
urządzać: imperf: subj{np(str)} + {np(str)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
urządzać się: imperf: subj{np(str)} + {prepnp(u,gen)}
urządzać się: imperf: subj{np(str)} + {xp(locat)}
urządzić: perf: subj{np(str)} + {np(str)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
urządzić się: perf: subj{np(str)} + {prepnp(u,gen)}
urządzić się: perf: subj{np(str)} + {xp(locat)}
usiąść: perf: subj{np(str)} + {prepnp(do,gen)}
usiąść: perf: subj{np(str)} + {prepnp(na,loc)}
usiąść: perf: subj{np(str)} + {xp(locat)}
usiłować: imperf: subj,controller{np(str)} + controlee{infp(_)}
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}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uspokoić się: perf: subj{np(str)} + {cp(że)}
uspokoić się: perf: subj{np(str)} + {ncp(inst,że)}
uspokoić się: perf: subj{np(str)} + {np(inst)}
uspołecznić: perf: subj{np(str)} + obj{np(str)}
uspołecznić się: perf: subj{np(str)}
usprawiedliwić: perf: subj{np(str)} + {np(str)} + {or}
usprawiedliwić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
usprawiedliwić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
usprawiedliwić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
usprawiedliwić się: perf: subj{np(str)} + {cp(że)}
usprawiedliwić się: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
usprawiedliwić się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,że)}
usprawiedliwić się: perf: subj{np(str)} + {or}
usprawiedliwić się: perf: subj{np(str)} + {prepnp(przed,inst)}
usprawniać: imperf: subj{np(str)} + obj{np(str)}
usprawniać się: imperf: subj{np(str)}
usprawnić: perf: subj{np(str)} + obj{np(str)}
usprawnić się: perf: subj{np(str)}
ustalać: imperf: subj{np(str)} + {cp(int)}
ustalać: imperf: subj{np(str)} + {cp(żeby)}
ustalać: imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
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)}
ustanowić: perf: subj{np(str)} + {np(inst)} + {refl}
ustanowić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ustawiać: imperf: subj{np(str)} + obj{np(str)} + {or}
ustawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ustawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ustawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
ustawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ustawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ustawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ustawiać się: imperf: subj{np(str)} + {prepnp(do,gen)}
ustawiać się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
ustawiać się: imperf: subj{np(str)} + {prepnp(w,loc)}
ustawiać się: imperf: subj{np(str)} + {xp(locat)}
ustawić: perf: subj{np(str)} + obj{np(str)} + {or}
ustawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ustawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ustawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ustawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ustawić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ustawić się: perf: subj{np(str)} + {prepnp(do,gen)}
ustawić się: perf: subj{np(str)} + {prepnp(w,loc)}
ustawić się: perf: subj{np(str)} + {xp(locat)}
ustępować: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
ustępować: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
ustępować: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ustępować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ustępować: imperf: subj{np(str)} + {prepnp(przed,inst)}
ustępować: imperf: subj{np(str)} + {prepnp(z,gen)}
usunąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
usunąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
usunąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(spod,gen)}
usunąć się: perf: subj{np(str)} + {prepnp(w,acc)}
usunąć się: perf: subj{np(str)} + {prepnp(z,gen)}
usuwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
usuwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
usuwać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(spod,gen)}
usuwać się: imperf: subj{np(str)} + {prepnp(od,gen)}
usuwać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
uszkodzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uszkodzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uszkodzić: perf: subj{np(str)} + {refl}
uszkodzić się: perf: subj{np(str)} + {np(dat)}
uśmiechać się: imperf: subj{cp(żeby)} + {np(dat)}
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)} + {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świadomić: perf: subj{np(str)} + {np(dat)} + {or}
uświadomić: perf: subj{np(str)} + obj{cp(int); cp(że)} + {np(dat)}
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); ncp(str,int); ncp(str,że)} + {np(dat)}
uświadomić: perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
utkwić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
utkwić: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
utkwić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
utkwić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utonąć: perf: subj{np(str)} + {prepnp(w,loc)}
utopić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utopić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utopić się: perf: subj{np(str)} + {prepnp(w,loc)}
utopić się: perf: subj{np(str)} + {xp(locat)}
utracić: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
utrudniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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)} + controlee{xp(mod)}
utrzymywać się: imperf: subj{np(str)} + {prepnp(przy,loc)}
utrzymywać się: imperf: subj{np(str)} + {xp(locat)}
utworzyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utworzyć się: perf: subj{np(str)} + {xp(locat)}
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)}
uważać: imperf: subj,controller{np(str)} + controlee{prepadjp(za,acc)} + {refl}
uważać: imperf: subj,controller{np(str)} + controlee{prepnp(za,acc)} + {refl}
uważać: imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
uważać: imperf: subj{np(str)} + controller{infp(_)} + controlee{prepadjp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{cp(że)} + controlee{prepadjp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{cp(że)} + controlee{prepnp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controlee{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}
uwielbiać: imperf: subj{np(str)} + {cp(jak)}
uwielbiać: imperf: subj{np(str)} + {infp(ndk)}
uwielbiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
uwielbiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
uwierzyć: perf: subj{np(str)} + {cp(gdy); cp(jak); cp(jeśli); cp(kiedy)}
uwierzyć: perf: subj{np(str)} + {cp(jakoby); cp(że); cp(żeby)}
uwierzyć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
uwierzyć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
uwierzyć: perf: subj{np(str)} + {prepncp(w,acc,że)}
uwierzyć: perf: subj{np(str)} + {prepnp(w,acc)}
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)}
uwzględniać: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że)}
uwzględnić: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby)}
uzależnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int)}
uzależnić się: perf: subj{np(str)} + {prepnp(od,gen)}
uzasadniać: imperf: subj{np(str)} + {cp(int)}
uzasadniać: imperf: subj{np(str)} + {cp(że)}
uzasadniać: imperf: subj{np(str)} + {ncp(str,że)}
uzasadniać: imperf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uzasadniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzasadniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uzasadniać: imperf: subj{np(str)} + {or}
uzbrajać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uzbrajać się: imperf: subj{np(str)} + {prepnp(w,acc)}
uzbroić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uzbroić się: perf: subj{np(str)} + {prepnp(w,acc)}
uzdrawiać: imperf: subj{np(str)} + {np(inst)} + {refl}
uzdrawiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzdrawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uzdrawiać: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
uzdrowić: perf: subj{np(str)} + {np(inst)} + {refl}
uzdrowić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzdrowić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uzdrowić: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
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)} + controlee{adjp(inst)} + {refl}
uznać: perf: subj,controller{np(str)} + controlee{np(inst)} + {refl}
uznać: perf: subj,controller{np(str)} + controlee{prepadjp(za,acc)} + {refl}
uznać: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
uznać: perf: subj,controller{np(str)} + controlee{prepnp(za,acc)} + {refl}
uznać: perf: subj{np(str)} + controller{cp(że)} + controlee{prepadjp(za,acc)}
uznać: perf: subj{np(str)} + controller{cp(że)} + controlee{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)} + controlee{adjp(inst)}
uznać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
uznać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
uznać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
uznać: perf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controlee{prepnp(za,acc)}
uznać: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controlee{prepadjp(za,acc)}
uznać: perf: subj{np(str)} + obj{cp(że)}
uznawać: imperf: subj,controller{np(str)} + controlee{adjp(inst)} + {refl}
uznawać: imperf: subj,controller{np(str)} + controlee{np(inst)} + {refl}
uznawać: imperf: subj,controller{np(str)} + controlee{prepadjp(za,acc)} + {refl}
uznawać: imperf: subj,controller{np(str)} + controlee{prepnp(za,acc)} + {refl}
uznawać: imperf: subj{np(str)} + controller{cp(że)} + controlee{prepadjp(jako,str)}
uznawać: imperf: subj{np(str)} + controller{cp(że)} + controlee{prepnp(jako,str)}
uznawać: imperf: subj{np(str)} + controller{cp(że)} + controlee{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)} + controlee{prepadjp(za,acc)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(inst)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controlee{prepnp(za,acc)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controlee{prepadjp(za,acc)}
uznawać: imperf: subj{np(str)} + obj{cp(że)}
uzupełniać: imperf: subj{np(str)} + {cp(że)}
uzupełniać: imperf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uzupełniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzupełniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
uzupełniać: imperf: subj{np(str)} + {or}
uzupełnić: perf: subj{np(str)} + {cp(że)}
uzupełnić: perf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uzupełnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzupełnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
uzupełnić: perf: subj{np(str)} + {or}
uzyskać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uzyskiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
użyć: perf: subj{np(str)} + obj,controller{np(gen)} + controlee{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żytkować: imperf: subj{np(str)} + obj{np(str)}
używać: imperf: subj{np(str)} + obj,controller{np(gen)} + controlee{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{np(str)} + {cp(int)}
wahać się: imperf: subj{np(str)} + {cp(żeby)}
wahać się: imperf: subj{np(str)} + {infp(_)}
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)}
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)} + controlee{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)} + {lexnp(str,pl,'kwiatek',natr)} + {preplexnp(od,gen,sg,'spód',natr)}
wąchać: imperf: subj{np(str)} + obj{np(str); cp(int)}
wątpić: imperf: subj{np(str)} + {cp(czy)}
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)} + {prepncp(w,acc,żeby)}
wątpić: imperf: subj{np(str)} + {prepnp(o,loc)}
wątpić: imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,czy); prepncp(w,acc,że)}
wbić: perf: subj{np(str)} + {cp(żeby)}
wbić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
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)} + {prepnp(na,acc); prepnp(w,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)} + 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)} + {prepnp(do,gen); prepnp(na,acc)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wchodzić: imperf: subj{np(str)} + {xp(perl)}
wchodzić: imperf: subj{np(str)} + {xp(temp)} + {preplexnp(w,acc,sg,'życie',natr)}
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)}
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(ż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)}
wezwać: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wezwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wezwać: perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
wezwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wędrować: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
wędrować: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wędrować: imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
wędrować: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wędrować: imperf: subj{np(str)} + {xp(perl)}
wiadomo: imperf: {np(dat)} + {np(str)} + {comprepnp(w kwestii)}
wiadomo: imperf: {np(dat)} + {np(str)} + {comprepnp(w sprawie)}
wiadomo: imperf: {np(dat)} + {np(str)} + {cp(jakoby)}
wiadomo: imperf: {np(dat)} + {np(str)} + {cp(żeby)}
wiadomo: imperf: {np(dat)} + {np(str)} + {prepncp(o,loc,jakoby); prepncp(o,loc,żeby)}
wiadomo: imperf: {np(dat)} + {np(str)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
wiadomo: imperf: {np(str)} + {prepnp(z,inst)}
wiązać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wiązać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wiązać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,inst)}
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: {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)} + controlee{prepadjp(jako,str)} + {refl}
widzieć: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {refl}
widzieć: imperf: subj{np(str)} + controller{np(str)} + controlee{adjp(str)}
widzieć: imperf: subj{np(str)} + controller{np(str)} + controlee{np(inst)}
widzieć: imperf: subj{np(str)} + {cp(int)} + {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(żeby)}
widzieć: imperf: subj{np(str)} + {cp(żeby2)} + {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)} + controlee{xp(mod)}
widzieć: imperf: subj{np(str)} + obj,controller{cp(że)} + controlee{xp(mod)}
widzieć: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
widzieć: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{infp(_)}
widzieć się: imperf: subj,controller{np(str)} + controlee{adjp(pred)} + {np(dat)}
widzieć się: imperf: subj,controller{np(str)} + controlee{np(inst)} + {np(dat)}
widzieć się: imperf: subj,controller{np(str)} + controlee{prepnp(jako,str)} + {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)}
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)}
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: {np(dat)} + {prepnp(w,loc)} + {xp(mod)}
wietrzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wietrzyć się: imperf: subj{np(str)} + {xp(locat)}
wieźć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wieźć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wieźć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
winien: imperf: subj,controller{np(str)} + controlee{infp(_)}
wisieć: imperf: subj,controller{np(str)} + {prepnp(na,loc)}
wisieć: imperf: subj{cp(int)} + {np(dat)}
wisieć: imperf: subj{cp(że)} + {np(dat)}
wisieć: imperf: subj{cp(że)} + {prepnp(nad,inst)}
wisieć: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
wisieć: imperf: subj{np(str); ncp(str,że)} + {prepnp(nad,inst)}
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)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wisieć: imperf: subj{np(str)} + {prepnp(przy,loc)}
wisieć: imperf: subj{np(str)} + {xp(locat)}
witać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
wjechać: perf: subj{np(str)} + {prepncp(z,inst,że)}
wjechać: perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)}
wjechać: perf: subj{np(str)} + {prepnp(w,acc)}
wjeżdżać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wjeżdżać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wjeżdżać: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wjeżdżać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
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)} + {prepnp(w,acc); prepncp(w,acc,żeby)}
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)} + 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)} + {preplexnp(między,acc,pl,'bajka',atr)}
włożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,żeby)}
wnieść: imperf: subj{np(str)} + {cp(int)}
wnieść: imperf: subj{np(str)} + {cp(że)}
wnieść: imperf: subj{np(str)} + {cp(żeby)}
wnieść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wnieść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wnieść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,inst)}
wnieść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wnieść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wnieść: imperf: subj{np(str)} + {prepncp(o,acc,żeby)}
wnieść: imperf: subj{np(str)} + {prepnp(o,acc)}
wnosić: imperf: subj{np(str)} + {cp(int)}
wnosić: imperf: subj{np(str)} + {cp(że)}
wnosić: imperf: subj{np(str)} + {cp(żeby)}
wnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(w,acc)}
wnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
wnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wnosić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wnosić: imperf: subj{np(str)} + {prepncp(o,loc,int)}
wnosić: imperf: subj{np(str)} + {prepnp(o,loc)}
woleć: imperf: subj,controller{np(str)} + controlee{infp(_)}
woleć: imperf: subj{np(str)} + controller{np(str)} + controlee{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(żeby)}
woleć: imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
wolno: imperf: controller{np(dat)} + controlee{infp(_)}
wolno: imperf: {cp(żeby)}
wolno: imperf: {np(dat)} + {np(str)}
wolno: imperf: {np(dat)} + {xp(mod)}
wołać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controlee{np(inst)}
wołać: imperf: subj{np(str)} + controller{prepnp(za,inst)} + controlee{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)} + controlee{np(nom)}
wołać: imperf: subj{np(str)} + obj,controller{prepnp(na,acc)} + controlee{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(do,gen)}
wpadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
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)}
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(do,gen)}
wpaść: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
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)} + {prepncp(w,acc,jak)}
wpatrywać się: imperf: subj{np(str)} + {prepnp(w,acc)}
wpisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wpisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wpisać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
wpłacać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wpłacać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wpłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wpłacić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wpłacić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wpłynąć: perf: subj{np(str)} + {prepnp(do,gen)}
wpłynąć: perf: subj{np(str)} + {prepnp(na,acc)}
wpłynąć: perf: subj{np(str)} + {xp(adl)}
wpływać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wpływać: imperf: subj{np(str)} + {prepnp(na,acc)}
wpływać: imperf: subj{np(str)} + {xp(adl)}
wprowadzać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprowadzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wprowadzać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wprowadzać się: imperf: subj{np(str)} + {xp(abl)}
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)} + {prepnp(na,acc)}
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)}
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ęczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)} + {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)}
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ąść: 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)} + controlee{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)} + controlee{prepnp(jako,str)}
wskazywać: imperf: subj{np(str)} + obj{np(str); cp(że)} + {np(dat)} + {np(inst)}
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)}
wspomagać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wspomagać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
wspomagać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wspomagać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wspomagać się: imperf: subj{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)}
współpracować: imperf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
współpracować: imperf: subj{np(str)} + {prepnp(w,loc)} + {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)}
wstać: perf: subj{np(str)} + {np(inst)}
wstać: perf: subj{np(str)} + {prepnp(od,gen)}
wstać: perf: subj{np(str)} + {prepnp(z,gen)}
wstać: perf: subj{np(str)} + {xp(abl)}
wstawać: imperf: subj{np(str)} + {np(inst)}
wstawać: imperf: subj{np(str)} + {prepnp(od,gen)}
wstawać: imperf: subj{np(str)} + {prepnp(z,gen)}
wstawać: imperf: subj{np(str)} + {xp(abl)}
wstąpić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wstąpić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
wstąpić: perf: subj{np(str)} + {prepnp(w,acc)}
wstąpić: perf: subj{np(str)} + {xp(adl)}
wstrzymać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wstrzymać: perf: subj{np(str)} + obj{np(str)} + {or}
wstrzymać się: perf: subj{np(str)} + {or}
wstrzymać się: perf: subj{np(str)} + {prepnp(od,gen)}
wstrzymać się: perf: subj{np(str)} + {prepnp(z,inst)}
wstrzymywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wstrzymywać: imperf: subj{np(str)} + obj{np(str)} + {or}
wstrzymywać się: imperf: subj{np(str)} + {prepnp(od,gen)}
wstrzymywać się: imperf: subj{np(str)} + {prepnp(z,inst)}
wstyd: imperf: controller{np(dat)} + controlee{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)} + controlee{infp(_)}
wstydzić się: imperf: subj{np(str)} + {cp(że)}
wstydzić się: imperf: subj{np(str)} + {np(gen); ncp(gen,że)}
wstydzić się: imperf: subj{np(str)} + {prepnp(za,acc)} + {or}
wszcząć: perf: subj{np(str)} + obj{np(str)}
wszcząć się: perf: subj{np(str)} + {xp(locat)}
wtrącić: perf: subj{np(str)} + {cp(że)}
wtrącić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wtrącić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wtrącić: perf: subj{np(str)} + {or}
wtrącić się: perf: subj{np(str)} + {or}
wtrącić się: perf: subj{np(str)} + {prepnp(do,gen)}
wtrącić się: perf: subj{np(str)} + {prepnp(w,acc)}
wybaczyć: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wybaczyć: perf: subj{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)} + {np(dat)}
wybierać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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{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)}
wybrać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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{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)}
wybuchnąć: perf: subj{np(str)} + {cp(że)}
wybuchnąć: perf: subj{np(str)} + {np(inst)} + {or}
wybudować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wybudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wybudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wychodzić: imperf: {prepadjp(na,acc)}
wychodzić: imperf: {prepncp(na,acc,że)}
wychodzić: imperf: {prepnp(na,acc)}
wychodzić: imperf: subj{cp(int)} + {fixed('na jaw')}
wychodzić: imperf: subj{np(str); cp(że); 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)} + {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)} + {prepnp(z,gen)}
wychodzić: imperf: subj{np(str)} + {xp(abl)}
wychodzić: imperf: subj{np(str)} + {xp(adl)}
wychodzić: perf: subj{np(str)} + obj{np(str)}
wychować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{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)} + controlee{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)} + controlee{xp(mod)}
wychowywać się: imperf: subj{np(str)} + {prepnp(na,loc)}
wychowywać się: imperf: subj{np(str)} + {xp(locat)}
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)}
wyciskać: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(z,gen)}
wyciskać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jak,str)}
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)} + obj{np(str)} + {xp(locat)}
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(str)} + {prepnp(z,gen)}
wycisnąć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jak,str)}
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(locat)}
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)}
wyczerpać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyczerpać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyczerpać się: perf: subj{np(str)} + {np(inst)}
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{np(str)} + controlee{adjp(pred)} + {np(dat)}
wydać się: perf: subj,controller{np(str)} + controlee{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ć: perf: subj{cp(że)}
wydarzyć: perf: subj{np(str)} + {np(dat)} + {xp(temp)}
wydarzyć: 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)} + controlee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(int)} + controlee{np(inst)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(kiedy)} + controlee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(żeby)} + controlee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(żeby)} + controlee{np(inst)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(że)} + controlee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(że)} + controlee{np(inst)} + {np(dat)}
wydawać się: imperf: subj,controller{E} + controlee{infp(ndk)} + {np(dat)}
wydawać się: imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controlee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controlee{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ąż')}
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)}
wyglądać: imperf: {cp(że)}
wyglądać: imperf: {prepncp(na,acc,że)}
wyglądać: imperf: subj,controller{np(str)} + controlee{prepadjp(na,acc)} + {np(dat)}
wyglądać: imperf: subj,controller{np(str)} + controlee{prepnp(na,acc)} + {np(dat)}
wyglądać: imperf: subj,controller{np(str)} + controlee{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łosić: imperf: subj{np(str)} + obj{np(str)}
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)}
wyjaśniać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
wyjaśniać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{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)} + controlee{prepadjp(jako,str)}
wyjaśnić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)}
wyjaśnić się: perf: subj,controller{np(str)} + controlee{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)}
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)}
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{cp(int)} + {fixed('na jaw')}
wyjść: perf: subj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyjść: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepadjp(na,acc)}
wyjść: perf: subj{np(str)} + {np(dat)} + {advp(misc)}
wyjść: perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'bok',natr)}
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)}
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,gen)}
wyjść: perf: subj{np(str)} + {prepnp(z,inst)}
wyjść: perf: subj{np(str)} + {xp(abl)}
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,inst)}
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}
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)}
wykonać: perf: subj,controller{np(str)} + obj{np(str)} + controlee{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)} + controlee{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)}
wykorzystać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
wykorzystać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{prepnp(jako,str)}
wykorzystywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
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)} + {np(inst)} + {refl}
wykupić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wykupić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wykupić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykupić: perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wykupić: perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
wykupić: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
wylewać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wylewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wylewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wylewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wylewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wylewać: imperf: subj{np(str)} + {prepnp(za,acc)}
wylewać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wylewać się: imperf: subj{np(str)} + {xp(abl)}
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)}
wyładować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyładować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyładować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
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)} + {prepnp(z,gen)}
wyładować się: perf: subj{np(str)} + {xp(locat)}
wyłamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyłamać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyłamać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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(z,gen)}
wyłączać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyłączać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(poza,acc)}
wyłączać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłączać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyłączać się: imperf: subj{np(str)} + {or}
wyłączać się: imperf: subj{np(str)} + {prepnp(z,gen)}
wyłączać się: imperf: subj{np(str)} + {xp(abl)}
wyłączyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyłączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(poza,acc)}
wyłączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłączyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyłączyć się: perf: subj{np(str)} + {prepnp(z,gen)}
wyłączyć się: perf: subj{np(str)} + {xp(abl)}
wyłonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyłonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłonić się: perf: subj{np(str)} + {prepnp(z,gen)}
wyłonić się: perf: subj{np(str)} + {xp(abl)}
wyłożyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
wyłożyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyłożyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wyłożyć się: perf: subj{np(str)} + {prepnp(na,loc)}
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(str); cp(żeby); ncp(str,że); ncp(str,ż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)} + controlee{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)}
wymieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wymieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wymieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wymieniać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wymienić: perf: subj{np(str)} + obj{np(str)} + {or}
wymienić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'imię',atr)}
wymienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wymienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wymienić się: perf: subj{np(str)} + {np(inst)} + {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)}
wymijać: imperf: subj{np(str)} + obj{np(str)}
wymijać: imperf: subj{np(str)} + {xp(locat)}
wymijać się: imperf: subj{np(str)} + {prepnp(od,gen)}
wymijać się: imperf: subj{np(str)} + {prepnp(z,inst)}
wymijać się: imperf: subj{np(str)} + {xp(locat)}
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)}
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)}
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)}
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)}
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)} + controlee{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)} + controlee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
wypadać: imperf: controller{np(dat)} + controlee{infp(_)}
wypadać: imperf: subj,controller{np(str)} + controlee{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)} + controlee{infp(_)}
wypaść: perf: subj,controller{np(str)} + controlee{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)}
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)}
wypić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wypić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wypić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wypić: perf: subj{np(str)} + {prepncp(za,acc,żeby)}
wypić: perf: subj{np(str)} + {prepnp(po,loc)}
wypłacać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypłacać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
wypłacać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wypłacać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypłacić się: perf: subj{np(str)} + {np(dat)} + {np(inst)}
wypłacić się: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wypłacić się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypogadzać: imperf: subj{np(str)} + {np(str)}
wypogadzać się: imperf: subj{np(str)}
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)} + controlee{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)} + controlee{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)}
wypracować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wypracować się: perf: subj{np(str)}
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)}
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}
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)}
wypuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
wypuścić: perf: subj{np(str)} + obj{np(str)} + {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)}
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)} + controlee{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)} + controlee{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)}
wyremontować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyremontować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
wyremontować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyremontować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
wyremontować: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(za,acc)}
wyremontować: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
wyrosnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrosnąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyróżniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyróżniać się: imperf: subj{np(str)} + {np(inst)}
wyróżniać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(spośród,gen)}
wyróżniać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
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)} + {np(str)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wyrwać: perf: subj{np(str)} + {xp(adl)}
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)}
wyrządzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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}
wysiadać: imperf: subj{np(str)} + {np(dat)}
wysiadać: imperf: subj{np(str)} + {prepnp(przy,loc)}
wysiadać: imperf: subj{np(str)} + {prepnp(z,gen)}
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łać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wysłać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {xp(adl)}
wysłuchać: perf: subj{np(str)} + obj{cp(int)}
wysłuchać: perf: subj{np(str)} + obj{cp(że)}
wysłuchać: perf: subj{np(str)} + obj{ncp(gen,int)}
wysłuchać: perf: subj{np(str)} + obj{ncp(gen,że)}
wysłuchać: perf: subj{np(str)} + obj{np(gen)}
wysłuchać: perf: subj{np(str)} + obj{np(str)}
wystarczać: imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc)}
wystarczać: imperf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
wystarczać: imperf: subj,controlee{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,controlee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: perf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: perf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystartować: perf: subj{np(str)} + {prepnp(do,gen)}
wystartować: perf: subj{np(str)} + {prepnp(w,loc)}
wystartować: perf: subj{np(str)} + {xp(abl)}
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)} + controlee{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)} + controlee{prepnp(jako,str)}
występować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
występować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
występować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
występować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
występować: imperf: subj{np(str)} + {prepnp(na,loc)}
występować: imperf: subj{np(str)} + {prepnp(przed,inst)}
występować: imperf: subj{np(str)} + {prepnp(u,gen)}
występować: imperf: subj{np(str)} + {prepnp(w,loc)}
występować: imperf: subj{np(str)} + {prepnp(z,gen)}
występować: imperf: subj{np(str)} + {xp(locat)}
wystosować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
wystosowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
wysuwać: imperf: subj{np(str)} + obj{np(str)} + {or}
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)}
wysuwać się: imperf: subj{np(str)} + {or}
wysyłać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wysyłać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wysyłać: imperf: subj{np(str)} + obj{np(str)} + {or}
wysyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wysyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wysyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
wysyłać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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świetlać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyświetlać się: imperf: subj{np(str)} + {xp(locat)}
wytłumaczyć: perf: subj{np(str)} + {np(dat)} + {cp(int)}
wytłumaczyć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wytłumaczyć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wytłumaczyć: perf: subj{np(str)} + {np(dat)} + {or}
wytłumaczyć: perf: subj{np(str)} + {np(inst)} + {cp(int)}
wytłumaczyć: perf: subj{np(str)} + obj{np(str)} + {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)}
wytrzymać: perf: subj{np(str)} + {np(str); ncp(str,że)}
wytrzymać: perf: subj{np(str)} + {or}
wytrzymać: perf: subj{np(str)} + {xp(dur)}
wytwarzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytwarzać się: imperf: subj{np(str)}
wywalczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)} + {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)}
wywodzić: imperf: subj{np(str)} + {cp(że)}
wywodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,gen)}
wywodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wywodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wywodzić: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wywodzić: imperf: subj{np(str)} + {or}
wywodzić się: imperf: subj{np(str)} + {prepnp(od,gen)}
wywodzić się: imperf: subj{np(str)} + {prepnp(z,gen)}
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)} + {prepnp(do,gen)}
wywracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywracać się: imperf: subj{np(str)}
wyzdrowieć: perf: subj{np(str)} + {prepnp(po,loc)}
wyzdrowieć: perf: subj{np(str)} + {prepnp(z,gen)}
wyznaczać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
wyznaczać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{prepnp(jako,str)}
wyznaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
wzbogacić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wzbogacić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wzbogacić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wzbogacić się: perf: subj{np(str)} + {np(inst)}
wzbogacić się: perf: subj{np(str)} + {prepnp(na,loc)}
wzbogacić się: perf: subj{np(str)} + {prepnp(o,acc)}
wzbogacić się: perf: subj{np(str)} + {prepnp(w,acc)}
wzbudzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wzbudzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wzbudzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wzbudzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)} + controlee{prepadjp(za,acc)}
wziąć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + {prepncp(od,gen,że)}
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)}
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)} + obj{np(str)} + {np(dat)} + {np(inst)}
wzmacniać się: imperf: subj{np(str)} + {np(inst)}
wzmocnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wzmocnić się: perf: subj{np(str)} + {np(inst)}
wznieść: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wznieść się: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wznieść się: perf: subj{np(str)} + {prepnp(na,acc)}
wznieść się: perf: subj{np(str)} + {prepnp(ponad,acc)}
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)}
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)}
wzywać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
wzywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wzywać: imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
wzywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaakceptować: perf: subj{np(str)} + {cp(int); ncp(str,int)}
zaakceptować: perf: subj{np(str)} + {cp(że); ncp(str,że)}
zaakceptować: perf: subj{np(str)} + obj{np(str)}
zaangażować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaangażować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaangażować się: perf: subj{np(str)} + {prepnp(do,gen)}
zaangażować się: perf: subj{np(str)} + {prepnp(w,acc)}
zaangażować się: perf: subj{np(str)} + {prepnp(w,loc)}
zaatakować: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zaatakować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zaatakować: perf: subj{np(str)} + obj{np(str)} + {or}
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(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{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
zabić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zabić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zabić: perf: subj{np(str)} + {refl}
zabiegać: imperf: subj{np(str)} + {prepncp(o,acc,żeby)}
zabiegać: imperf: subj{np(str)} + {prepnp(o,acc)}
zabierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zabierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zabierać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zabierać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zabierać się: imperf: subj{np(str)} + {prepnp(do,gen)}
zabierać się: imperf: subj{np(str)} + {prepnp(za,acc)}
zabierać się: imperf: subj{np(str)} + {xp(adl)}
zabijać: imperf: subj{np(str)} + {np(inst)} + {refl}
zabijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabijać: imperf: subj{np(str)} + obj{np(str)} + {xp(mod)}
zabijać się: imperf: subj{np(str)} + {prepnp(o,acc)}
zablokować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zablokować się: perf: subj{np(str)} + {prepnp(przy,loc)}
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)} + {or}
zabraniać: imperf: subj{np(str)} + controller{np(dat)} + controlee{np(gen); infp(_)}
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{np(gen)} + {np(dat)}
zabronić: perf: subj{np(str)} + controller{np(dat)} + controlee{np(gen); infp(_)}
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{np(gen)} + {np(dat)}
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)}
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)} + {prepnp(dla,gen)}
zachować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zachować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zachować się: perf: subj,controller{np(str)} + controlee{xp(mod)}
zachować się: perf: subj{np(str)} + {prepnp(na,loc)}
zachować się: perf: subj{np(str)} + {prepnp(przy,loc)}
zachować się: perf: subj{np(str)} + {prepnp(w,loc)}
zachowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zachowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zachowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zachowywać się: imperf: subj,controller{np(str)} + controlee{xp(mod)}
zachowywać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
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)}
zachwycić: perf: subj{cp(int)} + {np(str)}
zachwycić: perf: subj{cp(jak)} + {np(str)}
zachwycić: perf: subj{cp(kiedy)} + {np(str)}
zachwycić: perf: subj{cp(że)} + {np(str)}
zachwycić: perf: subj{ncp(str,int)} + {np(str)}
zachwycić: perf: subj{ncp(str,że)} + {np(str)}
zachwycić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycić się: perf: subj{np(str)} + {cp(gdy)}
zachwycić się: perf: subj{np(str)} + {cp(jak)}
zachwycić się: perf: subj{np(str)} + {cp(jeśli)}
zachwycić się: perf: subj{np(str)} + {cp(że)}
zachwycić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycić się: perf: subj{np(str)} + {or}
zachwycić się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zaciągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zaciągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zaciągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaciągnąć się: perf: subj{np(str)} + {np(inst)}
zaciągnąć się: perf: subj{np(str)} + {prepnp(do,gen)}
zaciągnąć się: perf: subj{np(str)} + {prepnp(na,acc)}
zaciekawić: perf: subj{cp(int)} + {np(str)}
zaciekawić: perf: subj{cp(że)} + {np(str)}
zaciekawić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaciekawić się: perf: subj{np(str)} + {cp(int)}
zaciekawić się: perf: subj{np(str)} + {cp(że)}
zaciekawić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaciekawić się: perf: subj{np(str)} + {or}
zacisnąć: perf: subj{np(str)} + {lexnp(gen,sg,'pas',natr)}
zacisnąć: perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zacisnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc); prepnp(wokół,gen)}
zacisnąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc); prepnp(wokół,gen)}
zacisnąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zacząć: perf: subj,controller{E} + controlee{infp(ndk)}
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)}
zaczynać: imperf: subj,controller{E} + controlee{infp(ndk)}
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)} + {cp(int)}
zadawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zadawać się: imperf: subj{np(str)} + {prepnp(z,inst)}
zadbać: perf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
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)}
zadowolić: perf: subj{cp(że)} + obj{np(str)}
zadowolić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)}
zadowolić się: perf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zadzwonić: perf: subj{np(str)} + {cp(int)}
zadzwonić: perf: subj{np(str)} + {np(dat)}
zadzwonić: perf: subj{np(str)} + {np(inst)}
zadzwonić: perf: subj{np(str)} + {or}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepnp(po,acc); prepnp(pod,acc)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
zadzwonić: perf: subj{np(str)} + {prepnp(o,acc)}
zadzwonić: perf: subj{np(str)} + {xp(locat)}
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)}
zagospodarować: perf: subj{np(str)} + obj{np(str)}
zagospodarować się: perf: subj{np(str)} + {xp(locat)}
zagotować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zagotować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagotować się: perf: {prepnp(od,gen)} + {xp(locat)}
zagotować się: perf: {prepnp(w,loc)}
zagotować się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
zagotować się: perf: subj{np(str)} + {prepnp(od,gen)}
zagrać: perf: subj{np(str)} + {np(inst)}
zagrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zagrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zagrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zagrać: perf: subj{np(str)} + {prepnp(na,acc)}
zagrać: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
zagrać: perf: subj{np(str)} + {prepnp(w,acc)}
zagradzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagrażać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zagrodzić: perf: subj{np(str)} + {np(inst)} + {refl}
zagrodzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zagrozić: perf: subj{np(str)} + {np(dat)} + {np(inst); cp(że); ncp(inst,że)}
zagwarantować: perf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
zagwarantować: perf: subj{np(str)} + {or}
zainstalować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zainstalować się: perf: subj{np(str)} + {prepnp(u,gen)}
zainstalować się: perf: subj{np(str)} + {xp(locat)}
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)}
zaistnieć: perf: subj{np(str)} + {prepnp(dla,gen)}
zaistnieć: perf: subj{np(str)} + {xp(temp)}
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)}
zajść: perf: subj{np(str)} + {np(dat)} + {np(str)}
zajść: perf: subj{np(str)} + {np(inst)}
zajść: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zajść: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zajść: perf: subj{np(str)} + {prepnp(w,acc)}
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)}
zakochać się: perf: subj{np(str)} + {prepnp(w,loc)}
zakończyć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{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)}
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)}
zakryć: perf: subj{np(str)} + {np(inst)} + {refl}
zakryć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zakryć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakryć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakupić: perf: subj{np(str)} + obj{np(part)} + {np(dat)}
zakupić: perf: subj{np(str)} + obj{np(part)} + {prepnp(od,gen)}
zakupić: perf: subj{np(str)} + obj{np(part)} + {prepnp(u,gen)}
zakupić: perf: subj{np(str)} + obj{np(part)} + {prepnp(za,acc)}
zakupić: perf: subj{np(str)} + obj{np(part)} + {xp(locat)}
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)}
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)} + obj{np(str)} + {np(inst)}
zalać się: perf: subj{np(str)} + {np(inst)}
zalać się: perf: subj{np(str)} + {prepnp(w,acc)}
zalecać: imperf: subj{np(str)} + controller{np(dat)} + controlee{infp(_)}
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)}
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)}
zaliczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaliczać: imperf: subj{np(str)} + obj{np(str)} + {prepadjp(do,gen)}
zaliczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaliczać: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
zaliczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaliczyć: perf: subj{np(str)} + obj{np(str)} + {prepadjp(do,gen)}
zaliczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaliczyć: perf: subj{np(str)} + {prepadjp(do,gen)} + {refl}
zaliczyć: perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
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)}
zamarznąć: perf: subj{np(str)}
zamienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zamienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zamienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zamienić się: perf: subj{np(str)} + {np(inst)}
zamienić się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zamienić się: perf: subj{np(str)} + {prepnp(w,acc)}
zamierzać: imperf: subj,controller{np(str)} + controlee{infp(_)}
zamierzać: imperf: subj{np(str)} + {nonch}
zamierzać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
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)}
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)}
zamordować: perf: subj{np(str)} + {np(inst)} + {refl}
zamordować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamordować: perf: subj{np(str)} + {xp(locat)} + {refl}
zamówić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(u,gen); xp(locat)}
zamówić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zamówić się: perf: subj{np(str)} + {prepnp(na,acc)}
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ślić: perf: subj,controller{np(str)} + controlee{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)} + {prepncp(nad,inst,że)}
zamyślić się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zaniedbywać: imperf: subj{np(str)} + obj{np(str)}
zaniedbywać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zaniepokoić: perf: subj{cp(że)} + {np(str)}
zaniepokoić: perf: subj{np(str); 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)}
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)}
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)}
zanotować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zanotować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zanotować: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
zanotować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zanotować: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
zanotować: perf: subj{np(str)} + {prepnp(w,loc)} + {or}
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)}
zaoszczędzić: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc)}
zaoszczędzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)} + {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)} + {xp(adl)}
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(inst)}
zapalić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapalić się: perf: subj{np(str)} + {np(inst)}
zapalić się: perf: subj{np(str)} + {or}
zapalić się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zapalić się: perf: subj{np(str)} + {prepnp(od,gen)}
zapalić się: perf: subj{np(str)} + {prepnp(w,loc)}
zapalić się: perf: subj{np(str)} + {xp(locat)}
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)} + controlee{adjp(pred)}
zapamiętać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
zapamiętać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
zaparzyć: perf: subj{np(str)} + {np(dat)} + {np(gen)}
zaparzyć: perf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
zaparzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaparzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaparzyć się: perf: subj{np(str)}
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ł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)}
zapinać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapinać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,inst)}
zapinać: imperf: subj{np(str)} + {refl}
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)}
zapisywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zapisywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapisywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapisywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapisywać się: imperf: subj{np(str)} + {np(dat)}
zapisywać się: imperf: subj{np(str)} + {prepnp(do,gen)}
zapisywać się: imperf: subj{np(str)} + {prepnp(na,acc)}
zaplanować: perf: subj,controller{np(str)} + controlee{infp(_)}
zaplanować: perf: subj{np(str)} + {cp(int)}
zaplanować: perf: subj{np(str)} + {cp(żeby)}
zaplanować: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
zaplanować: perf: subj{np(str)} + {or}
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)}
zapłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
zapobiegać: imperf: subj{np(str)} + {ncp(dat,żeby)}
zapobiegać: imperf: subj{np(str)} + {np(dat)}
zapominać: imperf: subj,controller{np(str)} + controlee{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)} + controlee{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)} + controlee{prepadjp(jako,str)}
zapowiadać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)}
zapowiadać się: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)}
zapowiedzieć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)} + controlee{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)}
zapoznać się: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
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}
zaprezentować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zaprezentować się: perf: subj,controller{np(str)} + controlee{xp(mod)}
zaprezentować się: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
zapuszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
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)}
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)}
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)} + controlee{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)} + controlee{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)} + controlee{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)}
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)}
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}
zarzucać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zarzucać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {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); ncp(str,że)} + {np(dat)}
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)}
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)}
zaskoczyć: perf: subj{np(str); cp(że); ncp(str,że)} + obj{np(str)}
zaskoczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaskoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
zaskoczyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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łużyć: perf: subj{np(str)} + {cp(żeby)}
zasłużyć: perf: subj{np(str)} + {np(inst); ncp(inst,jak); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,jak); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zasłużyć się: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,jak); ncp(inst,że)}
zasłużyć się: perf: subj{np(str)} + {np(inst); ncp(inst,jak); ncp(inst,że)} + {prepnp(dla,gen)}
zasnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
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)}
zaspokoić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaspokoić: perf: subj{np(str)} + obj{np(str)} + {or}
zaspokoić się: perf: subj{np(str)} + {np(inst)}
zastać: perf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(pred)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,inst)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zastać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastać się: perf: subj{np(str)}
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)}
zastąpić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zastąpić: perf: subj{np(str)} + obj{np(str)} + {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)}
zastępować: imperf: subj{np(str)} + obj{np(str)} + {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)}
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}
zaszkodzić: perf: subj,controlee{infp(_)} + controller{np(dat)}
zaszkodzić: perf: subj{cp(jakby)} + {np(dat)}
zaszkodzić: perf: subj{cp(jeśli)} + {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ś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}
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)} + controlee{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)} + controlee{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)} + controlee{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,acc); prepnp(w,loc)}
zatrudnić się: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
zatrudnić się: perf: subj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
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,inst,int)}
zatrzymać się: perf: subj{np(str)} + {prepnp(u,gen); 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,inst,int)}
zatrzymywać się: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
zatwierdzić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{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)}
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}
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)}
zawiadomić: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zawiadomić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zawiadomić: perf: subj{np(str)} + obj{np(str)} + {or}
zawiadomić: perf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,int)}
zawiadomić: perf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,że)}
zawiadomić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)}
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)}
zawiesić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)} + obj{np(str)} + {xp(locat)}
zawiesić: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zawiesić się: perf: subj{np(str)}
zawieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zawieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zawieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawieść: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zawieść się: perf: subj{np(str)} + {prepnp(na,loc)}
zawijać: imperf: subj{np(str)} + obj{np(str)} + {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)} + {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,gen)} + {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}
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)}
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)}
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)} + {ncp(str,int)}
zbadać: perf: subj{np(str)} + {np(inst)} + {cp(int)}
zbadać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zbadać się: perf: subj{np(str)} + {prepnp(u,gen)}
zbadać się: perf: subj{np(str)} + {xp(locat)}
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)}
zbiec: perf: subj{np(str)} + {xp(adl)}
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)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zbierać się: imperf: {np(dat)} + {prepnp(na,acc)}
zbierać się: imperf: subj{E} + {prepnp(na,acc)}
zbierać się: imperf: subj{np(str)} + {prepnp(do,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)}
zbliżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zbliżać się: imperf: subj{np(str)} + {prepnp(do,gen)}
zbliżyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zbliżyć się: imperf: subj{np(str)} + {prepnp(do,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)} + obj{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)}
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)} + controlee{np(inst)} + {np(dat)}
zdać się: perf: subj,controller{np(str)} + controlee{adjp(pred)} + {np(dat)}
zdać się: perf: subj,controller{np(str)} + controlee{infp(ndk)}
zdać się: perf: subj,controller{np(str)} + controlee{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,controlee{infp(_)} + controller{np(dat)} + {xp(temp)}
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(temp)}
zdarzyć: perf: subj{np(str)} + {cp(że)} + {xp(temp)}
zdarzyć się: perf: subj,controlee{infp(_)} + controller{np(dat)} + {xp(temp)}
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(temp)}
zdarzyć się: perf: subj{np(str)} + {xp(locat)}
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)} + controlee{np(inst)} + {np(dat)}
zdawać się: imperf: subj,controller{np(str)} + controlee{adjp(pred)} + {np(dat)}
zdawać się: imperf: subj,controller{np(str)} + controlee{infp(ndk)}
zdawać się: imperf: subj,controller{np(str)} + controlee{np(inst)} + {np(dat)}
zdawać się: imperf: subj{cp(że)} + {np(dat)}
zdawać się: imperf: subj{np(str)} + {prepnp(na,acc)}
zdążyć: perf: subj,controller{np(str)} + controlee{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)}
zdecydować: perf: subj,controller{np(str)} + controlee{infp(_)}
zdecydować: perf: subj{np(str)} + {advp(pron)}
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)} + controlee{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)}
zdefiniować: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(jako,str)}
zdefiniować: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepnp(jako,str)}
zdefiniować: perf: subj{np(str)} + obj{cp(int); ncp(str,int)}
zdefiniować: perf: subj{np(str)} + obj{cp(że); ncp(str,że)}
zdefiniować: perf: subj{np(str)} + obj{np(str)}
zdefiniować: perf: subj{np(str)} + {or}
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)}
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)}
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)}
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)} + controlee{infp(_)}
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)} + controlee{prepadjp(jako,str)} + {np(dat)}
zdradzać się: imperf: subj,controller{np(str)} + controlee{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)} + controlee{prepadjp(jako,str)} + {np(dat)}
zdradzić się: perf: subj,controller{np(str)} + controlee{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)}
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(do,gen)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
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)} + controlee{infp(_)}
zechcieć: perf: subj{np(str)} + {np(str)}
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(inst)} + {xp(abl)} + {xp(adl)}
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)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
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)}
zemrzeć: perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
zemrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zemrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
zemrzeć: perf: subj{np(str)} + {prepnp(dla,gen)}
zemrzeć: perf: subj{np(str)} + {prepnp(od,gen)}
zemrzeć: perf: subj{np(str)} + {prepnp(za,acc)}
zepsuć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zepsuć się: perf: subj{np(str)} + {np(dat)}
zerwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zerwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zerwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zerwać: perf: subj{np(str)} + {prepnp(z,inst)}
zerwać się: perf: subj{np(str)} + {or}
zerwać się: perf: subj{np(str)} + {prepnp(do,gen)}
zerwać się: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
zgadzać się: imperf: subj,controller{np(str)} + controlee{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)}
zginać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zginać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zginać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zginać się: imperf: subj{np(str)} + {prepnp(ku,dat)}
zginać się: imperf: subj{np(str)} + {prepnp(od,gen)}
zginać się: imperf: subj{np(str)} + {prepnp(pod,inst)}
zginać się: imperf: subj{np(str)} + {prepnp(w,acc)}
zginać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zginąć: perf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,pl,'oko',natr)}
zginąć: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
zginąć: perf: subj{np(str)} + {prepnp(na,loc)}
zginąć: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zginąć: perf: subj{np(str)} + {prepnp(w,loc)}
zginąć: perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
zginąć: perf: subj{np(str)} + {prepnp(z,gen)}
zginąć: perf: subj{np(str)} + {xp(locat)}
zgłaszać: imperf: subj{np(str)} + {cp(że)} + {xp(locat)}
zgłaszać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zgłaszać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zgłaszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zgłaszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zgłaszać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgłaszać się: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(u,gen); xp(adl); xp(locat)}
zgłaszać się: imperf: subj{np(str)} + {prepnp(na,acc)}
zgłaszać się: imperf: subj{np(str)} + {prepnp(po,acc)}
zgłaszać się: imperf: subj{np(str)} + {prepnp(z,inst)}
zgłosić: perf: subj{np(str)} + {cp(że)} + {xp(locat)}
zgłosić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zgłosić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zgłosić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zgłosić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zgłosić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgłosić się: perf: subj{np(str)} + {prepnp(do,gen); prepnp(u,gen); xp(adl); xp(locat)}
zgłosić się: perf: subj{np(str)} + {prepnp(na,acc)}
zgłosić się: perf: subj{np(str)} + {prepnp(po,acc)}
zgłosić się: perf: subj{np(str)} + {prepnp(z,inst)}
zgodzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zgodzić się: perf: subj,controller{np(str)} + controlee{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)}
zgromadzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgromadzić się: perf: subj{np(str)} + {xp(locat)}
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)} + {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)}
ziewać: imperf: subj{np(str)}
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)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(na,acc)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(przeciw,dat)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(w,loc)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(wokół,gen)}
zjeść: perf: subj{np(str)} + {advp(misc)}
zjeść: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
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)}
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)} + {np(dat)}
zlikwidować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
złamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
złamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zł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)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
złapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
złapać: perf: subj{np(str)} + {prepnp(na,acc)}
złapać: perf: subj{np(str)} + {prepnp(w,acc)}
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,że)}
złapać się: perf: subj{np(str)} + {prepnp(w,acc)}
złapać się: perf: subj{np(str)} + {prepnp(za,acc)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
złożyć 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)}
zmarnować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zmarnować się: perf: subj{np(str)}
zmęczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zmęczyć się: perf: subj{np(str)} + {np(inst)}
zmieniać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(na,acc)}
zmieniać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(w,acc)}
zmieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zmieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zmieniać się: imperf: subj,controller{np(str)} + controlee{prepadjp(na,acc)} + {prepadjp(z,gen)}
zmieniać się: imperf: subj,controller{np(str)} + controlee{prepadjp(w,acc)} + {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)} + controlee{prepadjp(na,acc)}
zmienić: perf: subj{np(str)} + obj,controller{np(str)} + controlee{prepadjp(w,acc)}
zmienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zmienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zmienić się: perf: subj,controller{np(str)} + controlee{prepadjp(na,acc)} + {prepadjp(z,gen)}
zmienić się: perf: subj,controller{np(str)} + controlee{prepadjp(w,acc)} + {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)}
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)}
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)}
zmoknąć: perf: subj,controller{np(str)} + controlee{xp(mod)} + {xp(locat)}
zmusić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zmusić: perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
zmusić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zmusić się: perf: subj{np(str)} + {cp(żeby)}
zmusić się: perf: subj{np(str)} + {prepnp(do,gen)}
zmuszać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zmuszać: imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
zmuszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zmuszać się: imperf: subj{np(str)} + {cp(żeby)}
zmuszać się: imperf: subj{np(str)} + {prepnp(do,gen)}
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)} + controlee{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)} + controlee{adjp(inst)}
znajdować: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(str)}
znajdować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
znajdować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
znajdować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znajdować się: imperf: subj,controller{np(str)} + controlee{adjp(inst)}
znajdować się: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
znajdować się: imperf: subj{np(str)} + {prepnp(w,loc)}
znajdywać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(inst)}
znajdywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
znajdywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
znajdywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znajdywać się: imperf: subj,controller{np(str)} + controlee{adjp(inst)}
znajdywać się: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
znajdywać się: imperf: subj{np(str)} + {prepnp(w,loc)}
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)} + controlee{adjp(inst)}
znaleźć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{adjp(str)}
znaleźć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
znaleźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
znaleźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znaleźć się: perf: subj,controller{np(str)} + controlee{adjp(inst)}
znaleźć się: perf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
znaleźć się: perf: subj{np(str)} + {prepnp(w,loc)}
znieść: perf: subj,controller{np(str)} + controlee{xp(mod)} + {cp(jak)}
znieść: perf: subj,controller{np(str)} + controlee{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)} + controlee{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)}
znosić: imperf: subj,controller{np(str)} + controlee{infp(ndk)}
znosić: imperf: subj,controller{np(str)} + controlee{xp(mod)} + {cp(jak)}
znosić: imperf: subj,controller{np(str)} + controlee{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)} + controlee{xp(mod)}
znosić: imperf: subj{np(str)} + {cp(gdy)}
znosić: imperf: subj{np(str)} + {cp(jak)}
znosić: imperf: subj{np(str)} + {cp(kiedy)}
znosić: imperf: subj{np(str)} + {cp(że)}
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)}
znosić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
znosić: perf: subj{np(str)} + obj{np(str)}
znosić się: imperf: subj{np(str)} + {prepnp(z,inst)}
zobaczyć: perf: subj{np(str)} + controller{np(str)} + controlee{adjp(str)}
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)} + controlee{adjp(inst)}
zobaczyć się: perf: subj{np(str)} + {prepnp(z,inst)}
zobowiązać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zobowiązać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
zobowiązać się: perf: subj{np(str)} + {np(inst)} + {cp(że)}
zobowiązać się: perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
zobowiązać się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zobowiązać się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
zobowiązać się: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
zobowiązać się: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
zobowiązywać: imperf: subj,controller{np(str)} + controlee{infp(_)} + {refl}
zobowiązywać: imperf: subj,controller{np(str)} + obj{np(str)} + controlee{infp(_)}
zobowiązywać: imperf: subj{np(str)} + {cp(żeby)} + {refl}
zobowiązywać: imperf: subj{np(str)} + {cp(że)} + {refl}
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)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
zorganizować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zorganizować: perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zorganizować się: perf: subj{np(str)} + {prepnp(w,acc)}
zorganizować się: perf: subj{np(str)} + {prepnp(wokół,gen)}
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,controlee{infp(_)} + controller{np(dat)}
zostać: perf: subj,controller{np(str)} + controlee{adjp(pred)}
zostać: perf: subj,controller{np(str)} + controlee{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(u,gen); xp(locat)}
zostać: perf: subj{np(str)} + {prepnp(z,inst)}
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)}
zostawać: imperf: controller{np(dat)} + controlee{infp(_)}
zostawać: imperf: subj,controller{np(str)} + controlee{adjp(pred)}
zostawać: imperf: subj,controller{np(str)} + controlee{np(inst)}
zostawać: imperf: subj{ncp(str,że)} + {np(dat)}
zostawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
zostawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
zostawać: imperf: subj{np(str)} + {prepnp(bez,gen)}
zostawać: imperf: subj{np(str)} + {prepnp(na,loc)}
zostawać: imperf: subj{np(str)} + {prepnp(przy,loc)}
zostawać: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
zostawać: imperf: subj{np(str)} + {prepnp(z,inst)}
zostawać się: imperf: subj{np(str)} + {prepnp(po,loc)}
zostawać się: imperf: subj{np(str)} + {prepnp(przy,loc)}
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)} + {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)}
zranić: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zranić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,acc)}
zranić się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
zrealizować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zrealizować się: perf: subj,controller{np(str)} + controlee{prepnp(jako,str)}
zrealizować się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zrezygnować: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
zrobić: perf: subj,controller{np(str)} + controlee{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)} + controlee{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)} + controlee{adjp(pred)}
zrobić się: perf: subj,controller{np(str)} + controlee{np(inst)}
zrobić się: perf: subj,controller{np(str)} + controlee{prepnp(na,acc)}
zrobić się: perf: subj{np(str)} + {prepnp(z,gen)}
zrodzić: perf: subj{np(str)} + obj{np(str)}
zrodzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrodzić się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
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)} + controlee{prepnp(jako,str)}
zrozumieć: perf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
zróżnicować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zróżnicować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zróżnicować się: perf: subj{np(str)} + {prepnp(na,acc)}
zrywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrywać: imperf: subj{np(str)} + {prepnp(z,inst)}
zrywać się: imperf: subj{np(str)} + {or}
zrywać się: imperf: subj{np(str)} + {prepnp(do,gen)}
zrywać się: imperf: subj{np(str)} + {prepnp(z,gen)}
zrzekać się: imperf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
zrzekać się: imperf: subj{np(str)} + {np(gen)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
zużyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zużyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zużyć się: perf: subj{np(str)} + {prepnp(od,gen)}
zwać: imperf: subj,controller{np(str)} + controlee{np(inst)} + {refl}
zwać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{np(inst)}
zwać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{np(nom)}
zwać: imperf: subj{np(str)} + obj,controller{np(str)} + controlee{xp(mod)}
zwać się: imperf: subj,controller{np(str)} + controlee{np(inst)}
zwać się: imperf: subj,controller{np(str)} + controlee{np(nom)}
zwać się: imperf: subj,controller{np(str)} + controlee{xp(mod)}
zwalniać: imperf: subj{np(str)} + {np(gen)}
zwalniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zwalniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwalniać się: imperf: subj{np(str)} + {prepnp(od,gen)}
zwalniać się: imperf: 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}
związać: perf: subj,controller{np(str)} + controlee{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)}
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)}
zwlec: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwlec: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zwlec się: perf: subj{np(str)} + {prepnp(z,gen)}
zwlec się: perf: subj{np(str)} + {xp(abl)}
zwlekać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwlekać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwlekać: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)} + {xp(dur)}
zwlekać się: imperf: subj{np(str)} + {prepnp(z,gen)}
zwlekać się: imperf: subj{np(str)} + {xp(abl)}
zwolnić: perf: subj{np(str)} + {np(gen)}
zwolnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zwolnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwolnić się: perf: subj{np(str)} + {prepnp(z,gen)}
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)} + controlee{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)} + controlee{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ęż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)} + controlee{infp(_)}
zwyknąć: perf: subj{np(str)} + {cp(żeby)}
zyskać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zyskać: perf: subj{np(str)} + {prepnp(na,loc)}
zyskać: perf: subj{np(str)} + {prepnp(w,loc)}
żal: imperf: controller{np(dat)} + controlee{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)}
żałować: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
żałować: imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,że)}
żałować: imperf: subj{np(str)} + {np(gen)} + {prepnp(na,acc)}
żałować: imperf: subj{np(str)} + {or}
żałować: imperf: subj{np(str)} + {prepnp(za,acc)}
żartować: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
żartować: perf: subj{np(str)} + {prepnp(z,gen)} + {or}
żartować: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
żartować: perf: subj{np(str)} + {prepnp(z,inst)}
żądać: imperf: subj{np(str)} + {np(gen); cp(żeby); ncp(gen,żeby)} + {prepnp(od,gen)}
żądać: imperf: subj{np(str)} + {or}
żegnać: imperf: subj{np(str)} + obj{np(str)}
żegnać się: imperf: subj{np(str)} + {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)}
życzyć: imperf: subj{np(str)} + controller{np(dat)} + controlee{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)} + controlee{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)}
