﻿
% The Polish Valence Dictionary (Walenty)
% September 09, 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 resource results from an automatic conversion
% of the aforementioned dictionary, manually reviewed by Filip
% Skwarski to include correct information about a number of new
% features, including sentential subjects, passivisation, and
% control relations.
%
% The format of the new dictionary has been established by Filip
% Skwarski, Elżbieta Hajnicz, Witold Kieraś, Agnieszka Patejuk,
% Adam Przepiórkowski, Marek Świdziński, and Marcin Woliński.
%
% The dictionary has been edited and compiled using a tool
% created by Bartłomiej Nitoń.
%
% The original Syntactic Dictionary of Polish Verbs derives from:
%
% Marek Świdziński
% Institute of Polish
% Warsaw University
% Warsaw, Poland
%
% © Copyright 1998,2012 by Marek Świdziński
%
% This work is distributed under a CC BY-SA license:
% http://creativecommons.org/licenses/by-sa/2.0/
%
% Parameters:
%     Vocabularies:   clarin1, clarin2, clarin3, clarin4, clarin5, clarin_diff, czas_czasu, czas_emotywne, czas_mentalne, czas_misc1, czas_misc2, czas_misc3, czas_mowienia, czas_operacji, czas_percepcji, czas_percepcji2, czas_przemieszczenia, frek1, frek10, frek2, frek3, frek4, frek5, frek6, frek7, frek8, frek9
%     Frame opinions: pewna, wątpliwa, archaiczna, potoczna
%     Lemma statuses: sprawdzone
%     Owners:         AnnaG, FilipS, JakubS, JoannaF, MaciejZ, MarcinO, MartaK, PaulinaR, PiotrB, SebasZ
%     Realizations:   None
%     Opinions added: False
%     
absorbować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
absorbować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
absorbować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(perl)}
administrować: imperf: subj{np(str)} + obj{np(inst)}
adoptować: _: subj{np(str)} + obj{np(str)} + {np(dat)}
adresować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
adresować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
akcentować: imperf: subj{np(str)} + {cp(że)}
akcentować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
akcentować: imperf: subj{np(str)} + {or}
akceptować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
akceptować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
akceptować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
akompaniować: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
akompaniować: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(na,loc)}
akompaniować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {comprepnp(w czasie)}
akompaniować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(podczas,gen)}
akompaniować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(przy,loc)}
akompaniować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {prepnp(w,loc)}
alarmować: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
alarmować: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
alarmować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)}
alarmować: imperf: subj{np(str)} + {or}
analizować: imperf: subj{np(str)} + obj{cp(int)}
analizować: imperf: subj{np(str)} + obj{np(str); ncp(str,int)}
angażować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
angażować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
angażować się: imperf: subj{np(str)} + {comprepnp(na rzecz)}
angażować się: imperf: subj{np(str)} + {prepnp(do,gen)}
angażować się: imperf: subj{np(str)} + {prepnp(w,acc)}
angażować się: imperf: subj{np(str)} + {prepnp(w,loc)}
anulować: perf: subj{np(str)} + {ncp(str,że)}
anulować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
apelować: imperf: subj{np(str)} + {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)}
aprobować: imperf: subj{np(str)} + {cp(że)}
aprobować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
aresztować: _: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
argumentować: imperf: subj{np(str)} + {cp(że)}
argumentować: imperf: subj{np(str)} + {cp(żeby)}
argumentować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
argumentować: imperf: subj{np(str)} + {or}
argumentować: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
argumentować: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)}
asystować: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc); prepncp(przy,loc,jak)}
asystować: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
asystować: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
asystować: imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
atakować: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
atakować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
atakować: imperf: subj{np(str)} + obj{np(str)} + {or}
awansować: _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
awansować: _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
awanturować się: imperf: subj{np(str)} + {comprepnp(z powodu)}
awanturować się: imperf: subj{np(str)} + {cp(int)}
awanturować się: imperf: subj{np(str)} + {cp(że)}
awanturować się: imperf: subj{np(str)} + {or}
awanturować się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
bać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
bać się: imperf: subj{np(str)} + {cp(int)}
bać się: imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
bać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {cp(żeby)}
bać się: imperf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
badać: imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
badać: imperf: subj{np(str)} + obj{cp(int)} + {np(inst)}
badać: imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
badać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
badać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
badać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
badać: imperf: subj{np(str)} + {or}
badać się: imperf: subj{np(str)} + {prepnp(na,acc)}
badać się: imperf: subj{np(str)} + {prepnp(u,gen)}
badać się: imperf: subj{np(str)} + {xp(locat)}
bagatelizować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
balansować: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
balansować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
balansować: imperf: subj{np(str)} + {prepnp(między,inst)}
balansować: imperf: subj{np(str)} + {prepnp(na,loc)}
balansować: imperf: subj{np(str)} + {prepnp(po,loc)}
balansować: imperf: subj{np(str)} + {prepnp(pomiędzy,inst)}
bandażować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
bankrutować: imperf: subj{np(str)} + {prepnp(na,loc)}
bawić: imperf: subj{cp(gdy)} + {np(str)}
bawić: imperf: subj{cp(int)} + {np(str)}
bawić: imperf: subj{cp(jak)} + {np(str)}
bawić: imperf: subj{cp(jeśli)} + {np(str)}
bawić: imperf: subj{cp(kiedy)} + {np(str)}
bawić: imperf: subj{np(str); cp(że); ncp(str,że)} + {np(str)}
bawić: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
bawić: imperf: subj{np(str)} + {prepnp(u,gen)}
bawić: imperf: subj{np(str)} + {xp(locat)}
bawić się: imperf: subj{np(str)} + {cp(że)}
bawić się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
bawić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
bawić się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
bazować: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
bełkotać: imperf: subj{np(str)} + {cp(że)} + {preplexnp(pod,inst,_,'nos',natr)}
bełkotać: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
bełkotać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)} + {or}
bełkotać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
bełkotać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,_,'nos',natr)}
bełkotać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
bełkotać: imperf: subj{np(str)} + {prepadjp(po,postp)}
bełkotać: imperf: subj{np(str)} + {preplexnp(pod,inst,_,'nos',natr)} + {or}
bełkotać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
bełkotać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
bełkotać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
bełkotać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
bić: imperf: subj{np(str)} + {np(dat)} + {lexnp(str,_,'brawo',atr)}
bić: imperf: subj{np(str)} + {np(dat)} + {lexnp(str,pl,'pokłon',atr)}
bić: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
bić: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
bić: imperf: subj{np(str)} + {np(str)}
bić: imperf: subj{np(str)} + obj{np(str)} + {fixed('na kwaśne jabłko')}
bić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'miazga',atr)}
bić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
bić: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'alarm',natr)}
bić: imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
bić: imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(inst,_,'czoło',natr)}
bić: imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(str,pl,'pokłon',atr)}
bić: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
bić: imperf: subj{np(str)} + {prepnp(z,gen)}
bić: imperf: subj{np(str)} + {xp(abl)}
bić się: imperf: subj{np(str)} + {cp(int)} + {preplexnp(z,inst,pl,'myśl',natr)}
bić się: imperf: subj{np(str)} + {preplexnp(w,acc,_,'pierś',natr)}
bić się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
bić się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
biec: imperf: subj,controller{np(str)} + controllee{infp(_)}
biec: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
biec: imperf: subj{np(str)} + {prepnp(za,inst)}
biec: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
biegać: imperf: {np(dat)} + {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)} + {xp(perl)}
blokować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
blokować się: imperf: subj{np(str)} + {prepnp(przy,loc)}
błagać: imperf: subj{np(str)} + {np(gen)}
błagać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
błagać: imperf: subj{np(str)} + {or}
błądzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
błądzić: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
błądzić: imperf: subj{np(str)} + {prepnp(w,loc)}
błądzić: imperf: subj{np(str)} + {xp(perl)}
błąkać się: imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
błąkać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
błąkać się: imperf: subj{np(str)} + {prepnp(w,loc)}
błąkać się: imperf: subj{np(str)} + {prepnp(wokół,gen)}
błąkać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
błąkać się: imperf: subj{np(str)} + {xp(perl)}
błogosławić: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
błogosławić: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
błogosławić: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
błogosławić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
błogosławić: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {refl}
błyszczeć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
błyszczeć się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
bogacić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
bogacić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
bogacić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
bogacić się: imperf: subj{np(str)} + {np(inst)}
bogacić się: imperf: subj{np(str)} + {prepnp(na,loc)}
bogacić się: imperf: subj{np(str)} + {prepnp(o,acc)}
bogacić się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
boleć: imperf: {np(str)} + {comprepnp(z powodu)} + {xp(locat)}
boleć: imperf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
boleć: imperf: {np(str)} + {prepnp(z,gen)} + {xp(locat)}
boleć: imperf: subj,controller{np(str)} + controllee{infp(_)}
boleć: imperf: subj{cp(że)} + {np(str)}
boleć: imperf: subj{lexnp(str,sg,'głowa',natr)} + {np(str)} + {prepncp(o,acc,int)}
boleć: imperf: subj{lexnp(str,sg,'głowa',natr)} + {np(str)} + {prepncp(o,acc,żeby)}
boleć: imperf: subj{lexnp(str,sg,'głowa',natr)} + {np(str)} + {prepnp(o,acc)}
boleć: imperf: subj{ncp(str,int)} + {np(str)}
boleć: imperf: subj{ncp(str,kiedy)} + {np(str)}
boleć: imperf: subj{np(str)} + {cp(że)}
boleć: imperf: subj{np(str); ncp(str,że)} + {np(str)}
boleć: imperf: subj{np(str)} + {np(str)} + {cp(że)}
boleć: imperf: subj{np(str)} + {or}
boleć: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
borykać się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
bożyć się: imperf: subj{np(str)} + {cp(że)}
brać: imperf: {np(str)} + {prepnp(na,acc)}
brać: imperf: subj{np(str)} + {cp(że)} + {preplexnp(do,gen,_,'siebie',natr)}
brać: imperf: subj{np(str)} + {lexnp(part,sg,'woda',natr)} + {preplexnp(w,acc,pl,'usta',natr)}
brać: imperf: subj{np(str)} + {ncp(str,że)} + {preplexnp(do,gen,_,'siebie',natr)}
brać: imperf: subj{np(str)} + {ncp(str,że)} + {preplexnp(na,acc,_,'siebie',natr)}
brać: imperf: subj{np(str)} + {np(str)}
brać: imperf: subj{np(str)} + {np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(do,gen)} + {lexnp(dat,_,'siebie',natr)}
brać: imperf: subj{np(str)} + {np(str)} + {preplexnp(do,gen,_,'siebie',natr)}
brać: imperf: subj{np(str)} + {np(str)} + {preplexnp(na,acc,_,'siebie',natr)}
brać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
brać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
brać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
brać: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
brać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {preplexnp(pod,acc,sg,'uwaga',atr)}
brać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
brać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
brać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
brać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
brać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
brać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
brać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
brać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
brać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
brać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
brać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
brać: imperf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,sg,'góra',natr)}
brać: imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'łapa',natr)}
brać: imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'skóra',natr)}
brać: imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
brać: imperf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(str,sg,'ślub',atr)}
brać się: imperf: subj{np(str)} + {preplexnp(w,acc,pl,'karb',natr)}
brać się: imperf: subj{np(str)} + {preplexnp(w,acc,sg,'garść',natr)}
brać się: imperf: subj{np(str)} + {prepnp(do,gen)}
brać się: imperf: subj{np(str)} + {prepnp(na,acc)}
brać się: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
brać się: imperf: subj{np(str)} + {prepnp(za,acc)}
brać się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
brać się: imperf: subj{np(str)} + {xp(abl)}
brak: imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
brak: imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
brak: imperf: {np(dat)} + {prepnp(dla,gen)} + {lexnp(gen,pl,'słowo',atr)}
brak: imperf: {np(dat)} + {prepnp(na,acc)} + {lexnp(gen,pl,'słowo',atr)}
brak: imperf: {np(gen)} + {xp(locat)}
braknąć: imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
braknąć: imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
braknąć: imperf: {np(dat)} + {prepnp(dla,gen)} + {lexnp(gen,pl,'słowo',atr)}
braknąć: imperf: {np(dat)} + {prepnp(na,acc)} + {lexnp(gen,pl,'słowo',atr)}
braknąć: imperf: {np(gen)} + {xp(locat)}
brakować: imperf: {np(dat)} + {cp(żeby)}
brakować: imperf: {np(dat)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
brnąć: imperf: subj{np(str)} + {cp(że)}
brnąć: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
brnąć: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
brnąć: imperf: subj{np(str)} + {prepnp(przez,acc)}
brnąć: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
brnąć: imperf: subj{np(str)} + {prepnp(za,inst)}
bronić: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
bronić: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
bronić: imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(przed,inst); prepncp(przed,inst,że)}
bronić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); prepncp(przed,inst,że)}
bronić się: imperf: subj{np(str)} + {cp(że)}
bronić się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst); prepncp(przed,inst,żeby)}
bronić się: imperf: subj{np(str)} + {or}
bronić się: imperf: subj{np(str)} + {prepnp(od,gen)}
brzmieć: imperf: controller{np(dat)} + controllee{xp(mod)} + {preplexnp(w,loc,pl,'ucho',natr)}
brzmieć: imperf: subj,controller{np(str)} + controllee{np(nom)}
brzmieć: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'usta',ratr)}
brzmieć: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',ratr)}
brzmieć: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(dla,gen)}
brzmieć: imperf: subj,controller{np(str); ncp(str,że)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',ratr)}
brzmieć: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(w,loc,pl,'ucho',ratr)}
brzmieć: imperf: subj{np(str)} + {prepnp(w,loc)}
brzydzić: imperf: subj{cp(gdy)} + {np(str)}
brzydzić: imperf: subj{cp(jak)} + {np(str)}
brzydzić: imperf: subj{cp(kiedy)} + {np(str)}
brzydzić: imperf: subj{cp(że)} + {np(str)}
brzydzić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {np(str)}
brzydzić się: imperf: subj,controller{np(str)} + controllee{infp(_)}
brzydzić się: imperf: subj{np(str)} + {cp(że)}
brzydzić się: imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
brzydzić się: imperf: subj{np(str)} + {np(inst); ncp(gen,int); ncp(inst,że)}
buchać: imperf: {np(inst)} + {prepnp(od,gen)}
buchać: imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
buchać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
buchnąć: perf: {np(inst)} + {prepnp(od,gen)}
buchnąć: perf: {np(inst)} + {xp(abl)} + {xp(adl)}
buchnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
buchnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
buchnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
buchnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
budować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
budować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
budować się: imperf: subj{np(str)} + {xp(locat)}
budzić: imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(wśród,gen)}
budzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
budzić się: imperf: subj{np(str)} + {comprepnp(z powodu)}
budzić się: imperf: subj{np(str)} + {prepnp(do,gen)}
budzić się: imperf: subj{np(str)} + {prepnp(między,inst)}
budzić się: imperf: subj{np(str)} + {prepnp(na,acc)}
budzić się: imperf: subj{np(str)} + {prepnp(od,gen)}
budzić się: imperf: subj{np(str)} + {prepnp(u,gen)}
budzić się: imperf: subj{np(str)} + {prepnp(w,loc)}
budzić się: imperf: subj{np(str)} + {prepnp(z,gen)}
buntować: imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
buntować: imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
buntować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
buntować się: imperf: subj{np(str)} + {prepncp(przeciw,dat,żeby)}
buntować się: imperf: subj{np(str)} + {prepnp(na,acc)}
buntować się: imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(w,loc)}
buntować się: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
buntować się: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)}
burzyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
burzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
burzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
burzyć się: imperf: subj{np(str)} + {or}
burzyć się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
burzyć się: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że)}
burzyć się: imperf: subj{np(str)} + {prepnp(w,loc)}
buszować: imperf: subj{np(str)} + {prepnp(po,loc); prepnp(u,gen); xp(locat)}
być: imperf: controller{np(dat)} + controllee{infp(_)} + {advp(misc)}
być: imperf: {np(dat)} + {cp(że)} + {advp(misc)}
być: imperf: {prepnp(z,inst)} + {advp(misc)}
być: imperf: subj,controller{cp(gdy)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(gdy)} + controllee{np(inst)}
być: imperf: subj,controller{cp(int)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(int)} + controllee{np(inst)}
być: imperf: subj,controller{cp(jak)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(jak)} + controllee{np(inst)}
być: imperf: subj,controller{cp(jakoby)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(jakoby)} + controllee{np(inst)}
być: imperf: subj,controller{cp(jeśli)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(jeśli)} + controllee{np(inst)}
być: imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(kiedy)} + controllee{np(inst)}
być: imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(żeby)} + controllee{np(inst)}
być: imperf: subj,controller{cp(że)} + controllee{adjp(pred)}
być: imperf: subj,controller{cp(że)} + controllee{np(inst)}
być: imperf: subj,controller{infp(_)} + controllee{adjp(pred)}
być: imperf: subj,controller{infp(_)} + controllee{np(inst)}
być: imperf: subj,controller{np(str)} + controllee{infp(_)}
być: imperf: subj,controller{np(str)} + controllee{np(nom)}
być: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jakoby); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
być: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jakoby); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
być: imperf: subj{np(str)} + {lexnp(gen,sg,'zdanie',atr)}
być: imperf: subj{np(str)} + {prepnp(na,loc)}
być: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(przeciw,dat,żeby); prepncp(za,inst,żeby)}
być: imperf: subj{np(str)} + {prepnp(przy,loc)}
być: imperf: subj{np(str)} + {prepnp(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: controller{np(dat)} + controllee{infp(_)} + {advp(misc)}
bywać: imperf: {np(dat)} + {cp(że)} + {advp(misc)}
bywać: imperf: {prepnp(z,inst)} + {advp(misc)}
bywać: imperf: subj,controller{cp(gdy)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{cp(gdy)} + controllee{np(inst)}
bywać: imperf: subj,controller{cp(int)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{cp(int)} + controllee{np(inst)}
bywać: imperf: subj,controller{cp(jak)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{cp(jak)} + controllee{np(inst)}
bywać: imperf: subj,controller{cp(jeśli)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{cp(jeśli)} + controllee{np(inst)}
bywać: imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{cp(kiedy)} + controllee{np(inst)}
bywać: imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{cp(żeby)} + controllee{np(inst)}
bywać: imperf: subj,controller{cp(że)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{cp(że)} + controllee{np(inst)}
bywać: imperf: subj,controller{infp(_)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{infp(_)} + controllee{np(inst)}
bywać: imperf: subj,controller{np(str)} + controllee{infp(_)}
bywać: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)}
bywać: imperf: subj,controller{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)}
bywać: imperf: subj{np(str)} + {lexnp(gen,sg,'zdanie',atr)}
bywać: imperf: subj{np(str)} + {prepnp(na,loc)}
bywać: imperf: subj{np(str)} + {prepnp(przy,loc)}
bywać: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)} + {xp(temp)}
bywać: imperf: subj{np(str)} + {prepnp(u,gen)} + {xp(temp)}
bywać: imperf: subj{np(str)} + {prepnp(w,loc)}
całować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
całować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
całować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {preplexnp(z,gen,sg,'dubeltówka',natr)}
całować: imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
całować: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
całować się: imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
całować się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
cechować: imperf: subj{cp(że)} + {np(str)}
cechować: imperf: subj{np(str)} + {np(str)}
cechować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
cechować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cechować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
cechować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
celebrować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(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)}
chadzać: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
chadzać: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {xp(abl)} + {xp(perl)}
chadzać: imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
chadzać: imperf: subj{np(str)} + {prepnp(w,loc)}
chadzać: imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
charakteryzować: imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {refl}
charakteryzować: imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {refl}
charakteryzować: imperf: subj{np(str); ncp(str,że)} + {np(str)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
charakteryzować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
charakteryzować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
chcieć: imperf: controller{np(str)} + controllee{cp(żeby); infp(_); advp(misc)}
chcieć: imperf: subj,controller{np(str)} + controllee{infp(_)}
chcieć: imperf: subj{np(str)} + {cp(że)}
chcieć: imperf: subj{np(str)} + {np(gen); cp(żeby); ncp(gen,żeby)} + {prepnp(od,gen)}
chcieć: imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
chcieć: imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc)}
chcieć: imperf: subj{np(str)} + {or}
chcieć: imperf: subj{np(str)} + {prepnp(do,gen)}
chcieć: imperf: subj{np(str)} + {xp(adl)}
chcieć się: imperf: controller{np(dat)} + controllee{infp(_)}
chcieć się: imperf: {np(dat)} + {np(gen)}
chichotać: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
chichotać: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
chichotać: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
chichotać się: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
chichotać się: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
chichotać się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
chłonąć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
chłonąć: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(perl)}
chodzić: imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
chodzić: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
chodzić: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
chodzić: imperf: subj{cp(żeby)} + {prepnp(za,inst)}
chodzić: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
chodzić: imperf: subj{cp(że)} + {prepnp(za,inst)}
chodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
chodzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
chodzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
chodzić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {xp(abl)} + {xp(perl)}
chodzić: imperf: subj{np(str)} + {prepnp(koło,gen)}
chodzić: imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
chodzić: imperf: subj{np(str)} + {prepnp(na,loc)}
chodzić: imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
chodzić: imperf: subj{np(str)} + {prepnp(w,loc)}
chodzić: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
chodzić: imperf: subj{np(str)} + {prepnp(z,inst)}
chodzić: imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'łóżka',natr)}
chodzić: imperf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'para',atr)}
chorować: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
chorować: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
chować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(adl)}
chować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
chować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
chować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
chować: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)} + {refl}
chować: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
chować się: imperf: subj{np(str)} + {prepnp(przy,loc)}
chować się: imperf: subj{np(str)} + {prepnp(z,inst)}
chować się: imperf: subj{np(str)} + {prepnp(z,inst); xp(locat)} + {advp(misc)}
chrapać: imperf: subj{np(str)}
chronić: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
chronić: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
chronić: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {refl}
chronić: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {refl}
chronić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
chronić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
chronić się: imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
chronić się: imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(locat)}
chronić się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
chronić się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
chwalić: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
chwalić: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
chwalić: imperf: subj{np(str)} + {np(str); ncp(str,że)}
chwalić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
chwalić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
chwalić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
chwalić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
chwalić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
chwalić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
chwalić się: imperf: subj{np(str)} + {np(dat)} + {np(inst); cp(że); ncp(inst,że)}
chwalić się: imperf: subj{np(str)} + {np(dat)} + {or}
chwalić się: imperf: subj{np(str)} + {np(inst); cp(że); ncp(inst,że)} + {prepnp(przed,inst)}
chwalić się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
chwalić się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
chwalić się: imperf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
chwycić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
chwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
chwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
chwycić: perf: subj{np(str)} + {prepnp(pod,acc)} + {refl}
chwycić się: perf: subj{np(str)} + {np(gen)}
chwycić się: perf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
chwytać: imperf: subj{np(str)} + obj{np(str)} + {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)} + {np(inst)} + {refl}
ciąć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepnp(w,acc)}
ciąć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ciąć: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ciąć się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
ciągnąć: imperf: {np(inst)} + {prepnp(od,gen)}
ciągnąć: imperf: {np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ciągnąć: imperf: subj{np(str)} + {cp(że)}
ciągnąć: imperf: subj{np(str)} + {np(str)} + {or}
ciągnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
ciągnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
ciągnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
ciągnąć: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
ciągnąć: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
ciągnąć się: imperf: subj{np(str)} + {prepnp(za,inst)}
ciągnąć się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
ciągnąć się: imperf: subj{np(str)} + {xp(dur)}
ciągnąć się: imperf: subj{np(str)} + {xp(perl)}
ciążyć: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
ciążyć: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
ciążyć: imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
ciążyć: imperf: subj{np(str)} + {prepnp(nad,inst)}
ciec: imperf: {np(dat)} + {xp(abl)}
ciec: imperf: {np(dat)} + {xp(adl)}
ciec: imperf: {np(dat)} + {xp(perl)}
ciec: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {xp(adl)}
ciec: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ciekawić: imperf: subj{cp(że)} + {np(str)}
ciekawić: imperf: subj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(str)}
ciekawić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
cierpieć: imperf: subj,controller{np(str)} + controllee{infp(_)}
cierpieć: imperf: subj{np(str)} + {comprepnp(z powodu)}
cierpieć: imperf: subj{np(str)} + {cp(gdy)}
cierpieć: imperf: subj{np(str)} + {cp(jak)}
cierpieć: imperf: subj{np(str)} + {cp(jeśli)}
cierpieć: imperf: subj{np(str)} + {cp(żeby2)}
cierpieć: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
cierpieć: imperf: subj{np(str)} + {prepnp(na,acc)}
cierpieć: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
cierpieć: imperf: subj{np(str)} + {prepnp(za,acc)}
cieszyć: imperf: subj{cp(że)} + {np(str)}
cieszyć: imperf: subj{np(str); ncp(str,że)} + {np(str)}
cieszyć: imperf: subj{np(str)} + {np(inst)} + {np(str)}
cieszyć się: imperf: subj{np(str)} + {cp(że)}
cieszyć się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
cieszyć się: imperf: subj{np(str)} + {or}
cieszyć się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
cisnąć: imperf: {np(str)} + {xp(locat)}
cisnąć: imperf: subj{cp(żeby)} + {np(str)}
cisnąć: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
cisnąć: imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
cisnąć: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
cisnąć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
cisnąć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
cisnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
cisnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
cisnąć: perf: {np(inst)} + {prepnp(o,acc)}
cisnąć: perf: {np(inst)} + {xp(adl)}
cisnąć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
cisnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
cisnąć: perf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
cisnąć: perf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
cisnąć: perf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
cisnąć: perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
cisnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
cisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
cisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
cisnąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
cisnąć się: imperf: subj{cp(int)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: imperf: subj{cp(żeby)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: imperf: subj{cp(że)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
cisnąć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: imperf: subj{np(str)} + {xp(adl)}
cisnąć się: imperf: subj{np(str)} + {xp(locat)}
cisnąć się: imperf: subj{or} + {np(dat)} + {prepnp(na,acc)}
cisnąć się: perf: subj{np(str)} + {xp(adl)}
cmokać: imperf: subj{np(str)} + {np(inst)}
cmokać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
cmokać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
cmokać: imperf: subj{np(str)} + {prepnp(na,acc)}
cmokać: imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
cmokać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
cmokać: imperf: subj{np(str)} + {prepnp(z,gen)}
cmoknąć: perf: subj{np(str)} + {np(inst)}
cmoknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
cmoknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
cmoknąć: perf: subj{np(str)} + {prepnp(na,acc)}
cmoknąć: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
cmoknąć: perf: subj{np(str)} + {prepnp(z,gen)}
cofać: imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofać: imperf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
cofać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
cofać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
cofać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
cofać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
cofać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
cofać się: imperf: subj{np(str)} + {np(dat)}
cofać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
cofać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
cofać się: imperf: subj{np(str)} + {prepncp(przed,inst,żeby)}
cofać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
cofać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
cofać się: imperf: subj{np(str)} + {xp(abl)}
cofać się: imperf: subj{np(str)} + {xp(adl)}
cofnąć: perf: subj{np(str)} + {np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofnąć: perf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
cofnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
cofnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
cofnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
cofnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
cofnąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
cofnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
cofnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
cofnąć się: perf: subj{np(str)} + {prepncp(przed,inst,żeby)}
cofnąć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
cofnąć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
cofnąć się: perf: subj{np(str)} + {prepnp(przed,inst)}
cofnąć się: perf: subj{np(str)} + {xp(abl)}
cofnąć się: perf: subj{np(str)} + {xp(adl)}
cuchnąć: imperf: controller{np(dat)} + controllee{xp(mod)} + {xp(abl)}
cuchnąć: imperf: controller{prepnp(od,gen)} + controllee{xp(mod)}
cuchnąć: imperf: controller{xp(locat)} + controllee{xp(mod)}
cuchnąć: imperf: {np(dat)} + {np(inst)} + {xp(abl)}
cuchnąć: imperf: {np(inst)} + {prepnp(od,gen)}
cuchnąć: imperf: {np(inst)} + {xp(locat)}
cuchnąć: imperf: subj,controller{np(str)} + controllee{xp(mod)}
cuchnąć: imperf: subj{np(str)} + {np(inst)}
cytować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)} + {or}
cytować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
cywilizować: imperf: subj{np(str)} + obj{np(str)}
cywilizować się: imperf: subj{np(str)}
czaić: imperf: subj{np(str)} + {cp(int)}
czaić: imperf: subj{np(str)} + {cp(że)}
czaić: imperf: subj{np(str)} + {np(str); ncp(str,że)}
czaić się: imperf: subj{np(str)} + {prepnp(do,gen)}
czaić się: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
czaić się: imperf: subj{np(str)} + {prepnp(w,loc)}
czaić się: imperf: subj{np(str)} + {prepnp(za,inst)}
czaić się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
czas: imperf: {infp(_)}
czas: imperf: {np(dat)} + {xp(adl)}
czas: imperf: {prepnp(na,acc)} + {cp(żeby)}
czas: imperf: {prepnp(na,acc); prepncp(na,acc,żeby)}
czatować: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
czatować: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
czatować: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
czatować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
czatować: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
czcić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
czcić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
czcić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
czekać: imperf: subj{np(str)} + {np(gen)}
czekać: imperf: subj{np(str)} + {np(str)}
czekać: imperf: subj{np(str)} + {prepnp(na,acc); cp(aż); cp(int); cp(jak); cp(kiedy); cp(że); cp(żeby); prepncp(na,acc,aż); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,kiedy); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)} + {xp(dur)}
czekać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(aż)} + {xp(dur)}
czekać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(dur)} + {xp(locat)}
czepiać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
czepiać się: imperf: subj{np(str)} + {np(gen)} + {cp(że)}
czepiać się: imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że)}
czepiać się: imperf: subj{np(str)} + {np(gen)} + {np(inst)}
czepiać się: imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
czepiać się: imperf: subj{np(str)} + {np(gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
czepiać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
czernić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
czernić się: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
czerpać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepnp(z,gen); prepncp(z,gen,że)}
czerpać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
czerwienić: imperf: subj{np(str)} + obj{np(str)}
czerwienić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
czerwienić się: imperf: subj{np(str)} + {np(inst)}
czesać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst)} + {refl}
czesać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
czesać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
czesać się: imperf: subj{np(str)} + {prepnp(u,gen)}
czesać się: imperf: subj{np(str)} + {xp(locat)}
częstować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
częstować się: imperf: subj{np(str)} + {np(inst)}
czuć: imperf: {cp(jak)} + {xp(locat)}
czuć: imperf: {cp(że)} + {xp(locat)}
czuć: imperf: {np(inst)} + {np(str)}
czuć: imperf: {np(inst)} + {prepnp(od,gen)}
czuć: imperf: {np(str)} + {prepnp(od,gen)}
czuć: imperf: {np(str)} + {xp(locat)}
czuć: imperf: subj{np(str)} + {cp(int)}
czuć: imperf: subj{np(str)} + {cp(jakby)}
czuć: imperf: subj{np(str)} + {cp(jak); cp(że)}
czuć: imperf: subj{np(str)} + {cp(jakoby)}
czuć: imperf: subj{np(str)} + {cp(żeby2)}
czuć: imperf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',atr)}
czuć: imperf: subj{np(str)} + {np(str); ncp(str,jak); ncp(str,że); ncp(str,żeby2)}
czuć: imperf: subj{np(str)} + {np(str)} + {preplexnp(przez,acc,sg,'skóra',natr)}
czuć: imperf: subj{np(str)} + {np(str)} + {preplexnp(w,loc,pl,'kość',natr)}
czuć: imperf: subj{np(str)} + {np(str)} + {prepnp(na,loc)}
czuć: imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
czuć: imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,pl,'mięta',natr)}
czuć się: imperf: subj,controller{np(str)} + controllee{adjp(pred)}
czuć się: imperf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(na,loc,_,'siła',natr)}
czuć się: imperf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
czuć się: imperf: subj,controller{np(str)} + controllee{np(inst)}
czuć się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
czuć się: imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
czuć się: imperf: subj{np(str)} + {np(gen)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
czulić się: imperf: subj{np(str)} + {prepnp(do,gen)}
czuwać: imperf: subj{np(str)} + {cp(żeby)}
czuwać: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
czuwać: imperf: subj{np(str)} + {prepnp(przy,loc)}
czuwać: imperf: subj{np(str)} + {xp(locat)}
czyhać: imperf: subj{np(str)} + {cp(żeby)}
czyhać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
czynić: imperf: subj,controller{np(str)} + controllee{xp(mod)}
czynić: imperf: subj{np(str)} + controller{np(str)} + controllee{adjp(inst)}
czynić: imperf: subj{np(str)} + controller{np(str)} + controllee{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)} + controllee{adjp(pred)}
czyścić: imperf: {np(str)}
czyścić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
czyścić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
czyścić: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
czyścić się: imperf: subj{np(str)}
czytać: imperf: subj{np(str)} + {cp(żeby)}
czytać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
czytać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
czytać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
czytać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
czytać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
czytać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
czytać: imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(int)}
czytać: imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
czytać: imperf: subj{np(str)} + {prepnp(o,loc)} + {or}
czytywać: imperf: subj{np(str)} + {cp(że)}
czytywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
czytywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
czytywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
czytywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ćwiczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ćwiczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ćwiczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ćwiczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ćwiczyć się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
dać: perf: {infp(_)} + {lexnp(str,sg,'rada',natr)}
dać: perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rada',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'czas',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'możliwość',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'okazja',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'prawo',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,_,'szansa',atr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'imię',natr)}
dać: perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)} + {preplexnp(na,acc,sg,'imię',natr)}
dać: perf: subj{np(str)} + {cp(żeby)} + {lexnp(str,sg,'rada',natr)}
dać: perf: subj{np(str)} + {cp(że)} + {lexnp(str,sg,'głowa',natr)}
dać: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
dać: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'myślenie',natr)}
dać: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'słowo',atr)}
dać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {lexnp(str,sg,'słowo',atr)}
dać: perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
dać: perf: subj{np(str)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
dać: perf: subj{np(str)} + obj{np(part)} + {np(dat)}
dać: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
dać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
dać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
dać się: perf: {infp(_)}
dać się: perf: subj{np(str)} + {np(dat)}
darować: _: subj{np(str)} + {np(dat)} + {cp(że)}
darować: _: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
darzyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
darzyć się: imperf: {np(dat)} + {advp(misc)}
darzyć się: imperf: {np(dat)} + {prepnp(w,loc)}
darzyć się: imperf: {np(dat)} + {xp(locat)}
darzyć się: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
datować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
datować: imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
datować się: imperf: subj{np(str)} + {prepnp(na,acc)}
datować się: imperf: subj{np(str)} + {xp(temp)}
dawać: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rada',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'czas',atr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'możliwość',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'okazja',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'prawo',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {lexnp(str,_,'szansa',atr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'imię',natr)}
dawać: imperf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)} + {preplexnp(na,acc,sg,'imię',natr)}
dawać: imperf: subj{np(str)} + {cp(żeby)} + {lexnp(str,sg,'rada',natr)}
dawać: imperf: subj{np(str)} + {cp(że)} + {lexnp(str,sg,'głowa',natr)}
dawać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(str)}
dawać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'myślenie',natr)}
dawać: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'słowo',atr)}
dawać: imperf: subj{np(str)} + {np(dat)} + {np(part)}
dawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {lexnp(str,sg,'słowo',atr)}
dawać: imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
dawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
dawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
dawać się: imperf: {infp(_)}
dawać się: imperf: subj{np(str)} + {np(dat)}
dążyć: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dążyć: imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
dążyć: imperf: subj{np(str)} + {xp(adl)}
dbać: imperf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
debiutować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(inst)} + {prepnp(przed,inst)} + {xp(locat)}
decydować: imperf: subj{np(str)} + {advp(pron)}
decydować: imperf: subj{np(str)} + {comprepnp(w sprawie)}
decydować: imperf: subj{np(str)} + {cp(int)}
decydować: imperf: subj{np(str)} + {cp(że)}
decydować: imperf: subj{np(str)} + {cp(żeby)}
decydować: imperf: subj{np(str); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
decydować: imperf: subj{np(str)} + {or}
decydować: imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
decydować się: imperf: subj,controller{np(str)} + controllee{infp(_)}
decydować się: imperf: subj{np(str)} + {cp(int)}
decydować się: imperf: subj{np(str)} + {cp(że)}
decydować się: imperf: subj{np(str)} + {cp(żeby)}
decydować się: imperf: subj{np(str)} + {or}
decydować się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
dedykować: _: subj{np(str)} + obj{np(str)} + {np(dat); prepnp(dla,gen)}
deklarować: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
deklarować: imperf: subj{np(str)} + {np(dat)} + {or}
deklarować: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
deklarować się: imperf: subj,controller{np(str)} + controllee{infp(_)}
deklarować się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
deklarować się: imperf: subj{np(str)} + {cp(int)}
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',ratr)}
deklarować się: imperf: subj{np(str)} + {prepnp(na,acc)}
deklarować się: imperf: subj{np(str)} + {prepnp(o,acc)}
deklarować się: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)}
dekorować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
delektować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
demonstrować: imperf: subj{np(str)} + {comprepnp(na rzecz)}
demonstrować: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
demonstrować: imperf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
demonstrować: imperf: subj{np(str)} + obj{cp(int)} + {prepnp(wobec,gen)}
demonstrować: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
demonstrować: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
demonstrować: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(wobec,gen)}
demonstrować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
demonstrować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
demonstrować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
demonstrować: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
demonstrować: imperf: subj{np(str)} + {prepnp(za,inst)}
denerwować: imperf: subj{cp(gdy)} + {np(str)}
denerwować: imperf: subj{cp(jak)} + {np(str)}
denerwować: imperf: subj{cp(jeśli)} + {np(str)}
denerwować: imperf: subj{cp(kiedy)} + {np(str)}
denerwować: imperf: subj{cp(że)} + {np(str)}
denerwować: imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
denerwować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
denerwować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
denerwować się: imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
denerwować się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
denerwować się: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
denerwować się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
denerwować się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
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)}
dobić: perf: subj{cp(gdy)} + {np(str)}
dobić: perf: subj{cp(jak)} + {np(str)}
dobić: perf: subj{cp(jeśli)} + {np(str)}
dobić: perf: subj{cp(kiedy)} + {np(str)}
dobić: perf: subj{cp(że)} + {np(str)}
dobić: perf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
dobić: perf: subj{np(str)} + obj{lexnp(gen,sg,'targ',natr)} + {prepnp(z,inst)}
dobić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
dobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dobić: perf: subj{np(str)} + {prepnp(do,gen)}
dobić się: perf: subj{np(str)} + {np(gen)}
dobiec: perf: subj{cp(jak)} + {np(gen)} + {xp(abl)}
dobiec: perf: subj{cp(jak)} + {prepnp(do,gen)} + {xp(abl)}
dobiec: perf: subj{cp(że)} + {np(gen)} + {xp(abl)}
dobiec: perf: subj{cp(że)} + {prepnp(do,gen)} + {xp(abl)}
dobiec: perf: subj{np(str)} + {np(gen)} + {xp(abl)}
dobiec: perf: subj{np(str)} + {np(str)} + {xp(abl)}
dobiec: perf: subj{np(str)} + {np(str)} + {xp(perl)}
dobiec: perf: subj{np(str); or} + {np(gen)} + {xp(abl)}
dobiec: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
dobiec: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)}
dobiec: perf: subj{np(str)} + {xp(adl)}
dobiec: perf: subj{or} + {np(str)} + {xp(abl)}
dobiec: perf: subj{or} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: imperf: subj{cp(jak)} + {np(gen)} + {xp(abl)}
dobiegać: imperf: subj{cp(jak)} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: imperf: subj{cp(że)} + {np(gen)} + {xp(abl)}
dobiegać: imperf: subj{cp(że)} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: imperf: subj{cp(że)} + {prepnp(do,gen)} + {xp(perl)}
dobiegać: imperf: subj{np(str)} + {np(gen)} + {xp(abl)}
dobiegać: imperf: subj{np(str)} + {np(str)} + {xp(abl)}
dobiegać: imperf: subj{np(str); or} + {np(gen)} + {xp(abl)}
dobiegać: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
dobiegać: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)}
dobiegać: imperf: subj{np(str)} + {xp(adl)}
dobiegać: imperf: subj{or} + {np(str)} + {xp(abl)}
dobiegać: imperf: subj{or} + {prepnp(do,gen)} + {xp(abl)}
dobierać: imperf: subj{np(str)} + obj{np(part)} + {xp(abl)} + {lexnp(dat,_,'siebie',natr)}
dobierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobierać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobierać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
dobijać: imperf: subj{cp(gdy)} + {np(str)}
dobijać: imperf: subj{cp(jak)} + {np(str)}
dobijać: imperf: subj{cp(jeśli)} + {np(str)}
dobijać: imperf: subj{cp(kiedy)} + {np(str)}
dobijać: imperf: subj{cp(że)} + {np(str)}
dobijać: imperf: subj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
dobijać: imperf: subj{np(str)} + obj{lexnp(gen,sg,'targ',natr)} + {prepnp(z,inst)}
dobijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
dobijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dobijać: imperf: subj{np(str)} + {prepnp(do,gen)}
dobijać się: imperf: subj{np(str)} + {np(gen)}
dobijać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
dobrać: perf: subj{np(str)} + obj{np(part)} + {xp(abl)} + {lexnp(dat,_,'siebie',natr)}
dobrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobrać się: perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
dobrać się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dobrać się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
dobrnąć: perf: subj{np(str)} + {prepnp(do,gen)}
dobrnąć: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {xp(perl)}
doceniać: imperf: subj{np(str)} + {cp(int)}
doceniać: imperf: subj{np(str)} + {cp(że)}
doceniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
doceniać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
doceniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
doceniać: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
docenić: imperf: subj{np(str)} + {cp(int)}
docenić: imperf: subj{np(str)} + {cp(że)}
docenić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
docenić: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(w,loc)}
docenić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
docenić: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
docierać: imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
docierać: imperf: subj{np(str)} + {np(part)}
docierać: imperf: subj{np(str)} + obj{np(str)}
docierać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
docierać się: imperf: subj{np(str)} + {prepnp(z,inst)}
doczekać: perf: subj{np(str)} + {cp(aż)}
doczekać: perf: subj{np(str)} + {np(gen); ncp(gen,że)}
doczekać: perf: subj{np(str)} + {prepnp(do,gen)}
doczekać się: perf: subj{np(str)} + {cp(aż)}
doczekać się: perf: subj{np(str)} + {cp(int)}
doczekać się: perf: subj{np(str)} + {cp(jak)}
doczekać się: perf: subj{np(str)} + {cp(że)}
doczekać się: perf: subj{np(str)} + {cp(żeby)}
doczekać się: perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
doczekać się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,aż); prepncp(na,acc,że); prepncp(na,acc,żeby)}
dodać: perf: subj{np(str)} + {np(dat)} + {np(gen)}
dodać: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dodać: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {prepnp(do,gen)}
dodać: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
dodawać: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
dodawać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dodawać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {prepnp(do,gen)}
dodawać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
dofinansować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dofinansować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dogadać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
dogadać: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
dogadać: perf: subj{np(str)} + {np(dat)} + {or}
dogadać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dogadać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
dogadać się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
dogadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
dogadywać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dogadywać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
dogadywać: imperf: subj{np(str)} + {np(dat)} + {or}
dogadywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dogadywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
dogadywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
dogadywać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
dogadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
doglądać: imperf: subj{np(str)} + {cp(int)}
doglądać: imperf: subj{np(str)} + {cp(jak)}
doglądać: imperf: subj{np(str)} + obj{np(gen)}
dojechać: perf: subj{np(str)} + {np(dat)}
dojechać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dojechać: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dojechać: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
dojechać: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
dojechać: perf: subj{np(str)} + obj{np(str)}
dojechać: perf: subj{np(str)} + {prepnp(na,loc)}
dojrzeć: perf: subj{np(str)} + {cp(int)}
dojrzeć: perf: subj{np(str)} + {cp(jak)}
dojrzeć: perf: subj{np(str)} + {cp(że)}
dojrzeć: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
dojrzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dojrzeć: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dojrzeć: perf: subj{np(str)} + {prepnp(w,loc)}
dojść: perf: {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dojść: perf: subj{cp(int)} + {prepnp(do,gen)}
dojść: perf: subj{cp(że)} + {prepnp(do,gen)}
dojść: perf: subj{np(str)} + {cp(int)}
dojść: perf: subj{np(str)} + {cp(że)}
dojść: perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
dojść: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
dojść: perf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'ład',natr)}
dojść: perf: subj{np(str)} + {xp(adl)}
dokładać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
dokładać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
dokładać: imperf: subj{np(str)} + {np(gen)} + {cp(żeby)}
dokładać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dokładać się: imperf: subj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dokonać: perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dokonać się: perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
dokonywać: imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dokonywać się: perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
dokończyć: perf: subj,controller{np(str)} + controllee{infp(imperf)}
dokończyć: perf: subj{np(str)} + {cp(że)}
dokończyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dokończyć: perf: subj{np(str)} + obj{np(str)} + {or}
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)}
dokumentować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
dokumentować: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
dolać: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dolatywać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dolatywać: imperf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(perl)}
dolatywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
dolecieć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dolecieć: perf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(perl)}
dolecieć: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
dolegać: imperf: subj{np(str)} + {np(dat)}
dolewać: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
doliczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
doliczyć: perf: subj{np(str)} + {prepnp(do,gen)}
doliczyć się: perf: subj{np(str)} + {np(gen)}
dołączać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dołączać się: imperf: subj{np(str)} + {prepnp(do,gen)}
dołączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dołączyć się: perf: subj{np(str)} + {prepnp(do,gen)}
dołożyć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
dołożyć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
dołożyć: perf: subj{np(str)} + {np(gen)} + {cp(żeby)}
dołożyć: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
dołożyć się: perf: subj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
domagać się: imperf: subj{np(str)} + {np(gen); cp(żeby); ncp(gen,żeby)} + {prepnp(od,gen)}
dominować: imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
dominować: imperf: subj{np(str)} + {prepnp(u,gen)}
dominować: imperf: subj{np(str)} + {prepnp(w,loc)}
dominować: perf: subj{np(str)} + obj{np(str)}
domyślać się: imperf: subj{np(str)} + {cp(żeby)}
domyślać się: imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
domyślać się: imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(z,gen)}
domyślać się: imperf: subj{np(str)} + {or}
domyślać się: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
domyślać się: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
domyślać się: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
domyślać się: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
domyślić się: perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
domyślić się: perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {prepnp(z,gen)}
domyślić się: perf: subj{np(str)} + {or}
domyślić się: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
domyślić się: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
domyślić się: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
domyślić się: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
donieść: perf: subj{np(str)} + {np(dat)} + {cp(int)}
donieść: perf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
donieść: perf: subj{np(str)} + {np(dat)} + {or}
donieść: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
donieść: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
donieść: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
donieść: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
donieść: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
donieść: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(jakoby)}
donieść: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
donieść: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
donieść się: perf: subj{cp(że)} + {prepnp(do,gen)}
donieść się: perf: subj{np(str)} + {xp(adl)}
donosić: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
donosić: imperf: subj{np(str)} + {np(dat)} + {cp(jakoby)}
donosić: imperf: subj{np(str)} + {np(dat)} + {or}
donosić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
donosić: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
donosić: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
donosić: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
donosić: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
donosić: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(jakoby)}
donosić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
donosić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
donosić: perf: subj{np(str)} + obj{np(str)}
donosić się: imperf: subj{np(str)} + {xp(abl)}
dookreślać: imperf: subj{np(str)} + {cp(że)}
dookreślać: imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
dookreślać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
dookreślać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dookreślać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dookreślać: imperf: subj{np(str)} + {prepnp(wobec,gen)} + {refl}
dookreślić: perf: subj{np(str)} + {cp(int)} + {refl}
dookreślić: perf: subj{np(str)} + {cp(że)}
dookreślić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
dookreślić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
dookreślić: perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
dookreślić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dookreślić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dopadać: perf: {np(gen)}
dopadać: perf: subj{np(str)} + {np(gen)}
dopadać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dopadać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dopadać: perf: subj{np(str)} + {prepnp(do,gen)}
dopadać się: perf: subj{np(str)} + {prepnp(do,gen)}
dopasować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopasować się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopasowywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopasowywać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopaść: perf: subj{np(str)} + {np(gen)}
dopaść: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dopaść: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
dopaść: perf: subj{np(str)} + {prepnp(do,gen)}
dopaść się: perf: subj{np(str)} + {prepnp(do,gen)}
dopatrywać: imperf: subj{np(str)} + {cp(int)}
dopatrywać: imperf: subj{np(str)} + {cp(że)}
dopatrywać: imperf: subj{np(str)} + {cp(żeby)}
dopatrywać: imperf: subj{np(str)} + {np(gen)}
dopatrywać się: imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby2)} + {prepnp(w,loc); prepncp(w,loc,że)}
dopatrywać się: imperf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
dopatrywać się: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
dopatrywać się: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
dopatrywać się: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby2)}
dopatrzyć: perf: subj{np(str)} + {cp(int)}
dopatrzyć: perf: subj{np(str)} + {cp(że)}
dopatrzyć: perf: subj{np(str)} + {cp(żeby)}
dopatrzyć: perf: subj{np(str)} + {np(gen)}
dopatrzyć się: perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby2)} + {prepnp(w,loc); prepncp(w,loc,że)}
dopatrzyć się: perf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
dopatrzyć się: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
dopatrzyć się: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
dopatrzyć się: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby2)}
dopełniać: imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dopełniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopełniać się: imperf: subj{np(str)}
dopełnić: perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dopełnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dopełnić się: perf: subj{np(str)}
dopilnować: perf: subj{np(str)} + obj{np(gen)} + {cp(int); cp(żeby)}
dopilnować: perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
dopisać: perf: subj{np(str)} + {cp(int)} + {xp(locat)}
dopisać: perf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
dopisać: perf: subj{np(str)} + obj{cp(że)} + {prepnp(do,gen)}
dopisać: perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
dopisać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen)}
dopisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
dopisać: perf: subj{np(str)} + obj{or} + {prepnp(do,gen)}
dopisać: perf: subj{np(str)} + obj{or} + {xp(locat)}
dopisać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
dopisać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
dopisać się: perf: subj{np(str)} + {prepnp(do,gen)}
dopłacać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(z,gen)}
dopłacać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
dopłacać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
dopłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(z,gen)}
dopłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
dopłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
dopomóc: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
dopomóc: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
dopomóc: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
dopomóc: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
dopomóc: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,żeby)}
dopowiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
dopowiadać: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(do,gen)}
dopowiadać: imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(do,gen)}
dopowiadać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
dopowiadać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
dopowiedzieć: perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
dopowiedzieć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(do,gen)}
doprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
doprowadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doprowadzać: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
doprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
doprowadzić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doprowadzić: perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
dopuszczać: imperf: subj{np(str)} + {cp(żeby)}
dopuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopuszczać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopuszczać się: imperf: subj{np(str)} + {np(gen); ncp(gen,że)}
dopuścić: perf: subj{np(str)} + {cp(żeby)}
dopuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
dopuścić: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dopuścić się: perf: subj{np(str)} + {np(gen); ncp(gen,że)}
dorabiać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
dorabiać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dorabiać się: imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {np(inst); ncp(inst,że)}
dorabiać się: imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
doradzać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
doradzać: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
doradzać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
doradzać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
doradzać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
doradzać: imperf: subj{np(str)} + {np(dat)} + {or}
doradzać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
doradzać: imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
doradzić: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
doradzić: perf: subj{np(str)} + {np(dat)} + {advp(misc)}
doradzić: perf: subj{np(str)} + {np(dat)} + {cp(int)}
doradzić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
doradzić: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
doradzić: perf: subj{np(str)} + {np(dat)} + {or}
doradzić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
doradzić: perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)}
dorastać: imperf: subj{np(str)} + {cp(żeby)}
dorastać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'pięta',natr)}
dorastać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {advp(misc)}
dorastać: imperf: subj{np(str)} + {prepnp(w,loc)}
dorastać: imperf: subj{np(str)} + {xp(locat)}
doręczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
doręczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'ręka',batr)}
doręczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doręczać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
doręczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
doręczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'ręka',batr)}
doręczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
doręczyć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dorobić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen)}
dorobić: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dorobić się: perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {np(inst); ncp(inst,że)}
dorobić się: perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
dorosnąć: perf: subj{np(str)} + {cp(żeby)}
dorosnąć: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,pl,'pięta',natr)}
dorosnąć: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {advp(misc)}
dorosnąć: perf: subj{np(str)} + {prepnp(w,loc)}
dorosnąć: perf: subj{np(str)} + {xp(locat)}
dorównać: perf: subj{np(str)} + {np(dat)} + {np(inst)}
dorównać: perf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dorównać: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
dorównywać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
dorównywać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
dorównywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
dorzucać: imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
dorzucać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dorzucać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
dorzucać: imperf: subj{np(str)} + obj{np(part)} + {xp(adl)}
dorzucać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
dorzucać: imperf: subj{np(str)} + {or}
dorzucać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
dorzucać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
dorzucać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
dorzucać się: imperf: subj{np(str)} + {prepnp(do,gen)}
dorzucać się: imperf: subj{np(str)} + {prepnp(na,acc)}
dorzucić: perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
dorzucić: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
dorzucić: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
dorzucić: perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
dorzucić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
dorzucić: perf: subj{np(str)} + {or}
dorzucić: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
dorzucić: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
dorzucić: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
dorzucić się: perf: subj{np(str)} + {prepnp(do,gen)}
dorzucić się: perf: subj{np(str)} + {prepnp(na,acc)}
dosiadać: imperf: subj{np(str)} + obj{np(gen)}
dosiadać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dosiadać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
dosiąść: perf: subj{np(str)} + {np(gen)}
dosiąść się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dosiąść się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
dosięgnąć: perf: subj{np(str)} + {np(gen)}
dosięgnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dosięgnąć: perf: subj{np(str)} + {np(str)} + {or}
dosięgnąć: perf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dosięgnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
doskwierać: imperf: subj{cp(że)} + {np(dat)}
doskwierać: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
dosłuchać: perf: subj{np(str)} + obj{np(str)}
dosłuchać się: perf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
dosłuchiwać: imperf: subj{np(str)} + obj{np(gen)}
dosłuchiwać się: imperf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
dosłyszeć: perf: subj{np(str)} + {cp(int)}
dosłyszeć: perf: subj{np(str)} + {cp(jak)}
dosłyszeć: perf: subj{np(str)} + {cp(że)}
dosłyszeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dosłyszeć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dostać: perf: subj,controller{np(str)} + controllee{infp(_)}
dostać: perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'nakaz',natr)}
dostać: perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'polecenie',natr)}
dostać: perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
dostać: perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'szansa',natr)}
dostać: perf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'zadanie',natr)}
dostać: perf: subj{np(str)} + {np(gen)}
dostać: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dostać: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dostać: perf: subj{np(str)} + {np(part)} + {prepnp(od,gen)}
dostać: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
dostać się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dostarczać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
dostarczyć: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
dostawać: imperf: subj,controller{np(str)} + controllee{infp(_)}
dostawać: imperf: subj{np(str)} + {np(gen)}
dostawać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dostawać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dostawać: imperf: subj{np(str)} + {np(part)} + {prepnp(od,gen)}
dostawać: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
dostawać: imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
dostawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dostawać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dostąpić: perf: subj{np(str)} + {np(gen); ncp(gen,że)}
dostąpić: perf: subj{np(str)} + {prepnp(do,gen)}
dostosować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostosować: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
dostosować się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostosowywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostosowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
dostosowywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dostrzec: perf: subj{np(str)} + {cp(jak)}
dostrzec: perf: subj{np(str)} + {cp(żeby2)}
dostrzec: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzec: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dostrzegać: imperf: subj{np(str)} + {cp(jak)}
dostrzegać: imperf: subj{np(str)} + {cp(żeby2)}
dostrzegać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
dostrzegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
doszukać się: perf: subj{np(str)} + {cp(int)}
doszukać się: perf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(w,loc); prepncp(w,loc,że)}
doszukać się: perf: subj{np(str)} + {np(gen)} + {xp(locat)}
doszukać się: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
doszukiwać się: imperf: subj{np(str)} + {cp(int)}
doszukiwać się: imperf: subj{np(str)} + {cp(że)}
doszukiwać się: imperf: subj{np(str)} + {np(gen); ncp(gen,że)} + {prepnp(w,loc); prepncp(w,loc,że)}
doszukiwać się: imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
dośrodkować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dośrodkować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
dośrodkować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
doświadczać: imperf: subj{np(str)} + {cp(int)}
doświadczać: imperf: subj{np(str)} + {cp(że)}
doświadczać: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)} + {np(inst)}
doświadczyć: perf: subj{np(str)} + {cp(int)}
doświadczyć: perf: subj{np(str)} + {cp(że)}
doświadczyć: perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)} + {np(inst)}
dotknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dotknąć: perf: subj{np(str)} + obj{np(gen)}
dotknąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dotknąć się: perf: subj{np(str)} + {np(gen)}
dotknąć się: perf: subj{np(str)} + {prepnp(do,gen)}
dotrwać: perf: subj{np(str)} + {cp(aż)}
dotrwać: perf: subj{np(str)} + {np(gen)}
dotrwać: perf: subj{np(str)} + {prepnp(do,gen)}
dotrzeć: perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(do,gen)}
dotrzeć: perf: subj{np(str)} + {np(part)}
dotrzeć: perf: subj{np(str)} + obj{np(str)}
dotrzeć: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
dotrzeć się: perf: subj{np(str)} + {prepnp(z,inst)}
dotrzymać: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'koło',natr)}
dotrzymać: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'pole',natr)}
dotrzymać: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'tempo',natr)}
dotrzymać: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'towarzystwo',natr)}
dotrzymać: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'wierność',natr)}
dotrzymać: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {lexnp(gen,sg,'krok',natr)}
dotrzymać: perf: subj{np(str)} + obj{np(gen)}
dotrzymać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dotrzymywać: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'koło',natr)}
dotrzymywać: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'pole',natr)}
dotrzymywać: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'tempo',natr)}
dotrzymywać: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'towarzystwo',natr)}
dotrzymywać: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'wierność',natr)}
dotrzymywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {lexnp(gen,sg,'krok',natr)}
dotrzymywać: imperf: subj{np(str)} + obj{np(gen)}
dotrzymywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
dotyczyć: imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
dotykać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
dotykać: imperf: subj{np(str)} + obj{np(gen)} + {np(inst)}
dotykać: imperf: subj{np(str)} + obj{np(str)}
dotykać się: imperf: subj{np(str)} + {np(gen)}
dotykać się: imperf: subj{np(str)} + {prepnp(do,gen)}
dowiadywać się: imperf: subj{np(str)} + {np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(u,gen); prepnp(z,gen)}
dowiadywać się: imperf: subj{np(str)} + {np(gen)} + {prepnp(o,loc)} + {prepnp(od,gen)}
dowiadywać się: imperf: subj{np(str)} + {or}
dowiadywać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(u,gen)}
dowiedzieć się: perf: subj{np(str)} + {np(gen); prepnp(o,loc); cp(int); cp(że); ncp(gen,int); ncp(gen,że); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(u,gen); prepnp(z,gen)}
dowiedzieć się: perf: subj{np(str)} + {np(gen)} + {prepnp(o,loc)} + {prepnp(od,gen)}
dowiedzieć się: perf: subj{np(str)} + {or}
dowiedzieć się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(u,gen)}
dowieść: perf: subj{np(str); ncp(str,że)} + obj{np(gen); ncp(gen,że)} + {np(dat)} + {np(inst)}
dowieść: perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
dowieźć: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowieźć: perf: subj{np(str)} + obj{np(part)} + {np(inst)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
dowodzić: imperf: subj{ncp(str,że)} + obj{cp(że)}
dowodzić: imperf: subj{np(str); ncp(str,że)} + obj{np(gen); ncp(gen,że)} + {np(dat)} + {np(inst)}
dowodzić: imperf: subj{np(str)} + {np(dat)} + {or}
dowodzić: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
dowodzić: imperf: subj{np(str)} + obj{np(inst)}
dowozić: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dowozić: imperf: subj{np(str)} + obj{np(part)} + {np(inst)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
doznać: perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)}
doznawać: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że)}
dożyć: perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dożyć: perf: subj{np(str)} + {np(str)}
dożyć: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
dożywać: imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
dożywać: imperf: subj{np(str)} + {np(str)}
dożywać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
drażnić: imperf: subj{cp(kiedy)} + {np(str)}
drażnić: imperf: subj{cp(że)} + {np(str)}
drażnić: imperf: subj{ncp(str,kiedy)} + {np(str)}
drażnić: imperf: subj{np(str); ncp(str,że)} + {np(str)}
drażnić: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
drażnić się: imperf: subj{np(str)} + {prepnp(z,inst)}
drążyć: imperf: subj{np(str)} + {cp(int)}
drążyć: imperf: subj{np(str)} + {cp(że)}
drążyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
drążyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
dreptać: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
dreptać: imperf: subj{np(str)} + {np(inst)}
dreptać: imperf: subj{np(str)} + {prepnp(koło,gen); prepncp(koło,gen,żeby)}
dreptać: imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,żeby)}
dreptać: imperf: subj{np(str)} + {prepnp(za,inst)}
dreptać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
dreptać: imperf: subj{np(str)} + {xp(locat)}
dręczyć: imperf: subj{np(str)} + {cp(że)} + {refl}
dręczyć: imperf: subj{np(str)} + {ncp(inst,że)} + {refl}
dręczyć: imperf: subj{np(str)} + {np(inst)} + {refl}
dręczyć: imperf: subj{np(str)} + {np(str)} + {cp(że)}
dręczyć: imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
dręczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
drgać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
drgać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
drgać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drgać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
drgać: imperf: subj{np(str)} + {np(inst)}
drgnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
drgnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
drgnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drgnąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
drgnąć: perf: subj{np(str)} + {np(inst)}
drobić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
drobić: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
drobić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
drobić: imperf: subj{np(str)} + {prepnp(za,inst)}
drobić: imperf: subj{np(str)} + {xp(perl)}
drożeć: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)} + {prepnp(z,gen)}
drukować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
drukować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
drukować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
drzeć: imperf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'włos',natr)} + {preplexnp(z,gen,sg,'głowa',natr)}
drzeć: imperf: subj{np(str)} + {np(str)} + {cp(że)}
drzeć: imperf: subj{np(str)} + {np(str)} + {cp(żeby)}
drzeć: imperf: subj{np(str)} + {np(str)} + {prepncp(o,acc,że)}
drzeć: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)} + {or}
drzeć: imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)} + {or}
drzeć: imperf: subj{np(str)} + {np(str)} + {prepnp(o,acc)}
drzeć: imperf: subj{np(str)} + {np(str)} + {prepnp(przeciw,dat)}
drzeć: imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc)}
drzeć: imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
drzeć: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
drzeć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
drzeć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
drzeć: imperf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(str,pl,'kot',natr)}
drzeć: imperf: subj{np(str)} + {xp(adl)}
drzeć się: imperf: subj{np(str)} + {prepncp(o,acc,że)}
drzeć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); cp(żeby)}
drzeć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
drzeć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
drzeć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
drzeć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)} + {or}
drzeć się: imperf: subj{np(str)} + {prepnp(z,inst)}
drzeć się: imperf: subj{np(str)} + {xp(adl)}
drzemać: imperf: subj{np(str)} + {prepnp(nad,inst)}
drzemać: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(u,gen)}
drzemać: imperf: subj{np(str)} + {prepnp(w,loc)}
drzemać: imperf: subj{np(str)} + {xp(locat)}
drżeć: imperf: subj{np(str)} + {cp(czy)}
drżeć: imperf: subj{np(str)} + {cp(że)}
drżeć: imperf: subj{np(str)} + {cp(żeby)}
drżeć: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
drżeć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
drżeć: imperf: subj{np(str)} + {or}
drżeć: imperf: subj{np(str)} + {preplexnp(w,loc,pl,'posada',natr)}
drżeć: imperf: subj{np(str)} + {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)}
dumać: imperf: subj{np(str)} + {cp(int)}
dumać: imperf: subj{np(str)} + {cp(że)}
dumać: imperf: subj{np(str)} + {or}
dumać: imperf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
dusić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dusić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dusić się: imperf: subj{np(str)} + {comprepnp(z powodu)}
dusić się: imperf: subj{np(str)} + {np(inst)}
dusić się: imperf: subj{np(str)} + {prepnp(od,gen)}
dusić się: imperf: subj{np(str)} + {prepnp(w,loc)}
dusić się: imperf: subj{np(str)} + {prepnp(z,gen)}
dusić się: imperf: subj{np(str)} + {xp(locat)}
dwoić: imperf: subj{np(str)} + obj{np(str)}
dwoić się: imperf: subj{np(str)}
dwoić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {preplexnp(przed,inst,pl,'oko',natr)}
dwoić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
dwoić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {preplexnp(przed,inst,pl,'oko',natr)}
dwoić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {preplexnp(w,loc,pl,'oko',natr)}
dygotać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
dygotać: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
dygotać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
dymić: imperf: subj{E} + {np(dat)} + {xp(abl)}
dymić: imperf: subj{E} + {xp(locat)}
dymić: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
dymić: imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
dymić: imperf: subj{np(str)} + {prepnp(od,gen)}
dymić: imperf: subj{np(str)} + {xp(locat)}
dymić się: imperf: subj{E} + {np(dat)} + {xp(abl)}
dymić się: imperf: subj{E} + {xp(locat)}
dymić się: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
dymić się: imperf: subj{np(str)} + {prepnp(od,gen)}
dymić się: imperf: subj{np(str)} + {xp(locat)}
dyskryminować: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
dyskryminować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,gen); prepncp(za,acc,int); prepncp(za,acc,że)}
dyskutować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dyskutować: imperf: subj{np(str)} + {or}
dyskutować: imperf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); comprepnp(na temat); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
dyskutować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
dyskutować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
dyskutować: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
dysponować: imperf: subj{np(str)} + {np(inst)}
dysponować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dysponować: imperf: subj{np(str)} + {or}
dyszeć: imperf: subj{np(str)} + {fixed('ledwie')}
dyszeć: imperf: subj{np(str)} + {fixed('ledwo')}
dyszeć: imperf: subj{np(str)} + {np(inst)}
dziać się: imperf: controller{np(dat)} + controllee{xp(mod)}
dziać się: imperf: subj{np(str)} + {np(dat)}
dziać się: imperf: subj{np(str)} + {prepnp(z,inst)}
dziać się: imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
działać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
działać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
działać: imperf: subj{np(str)} + {xp(locat)}
dziedziczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
dzielić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
dzielić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
dzielić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
dzielić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
dzielić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
dzielić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
dzielić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
dzielić się: imperf: subj{np(str)} + {prepnp(na,acc)}
dzielić się: imperf: subj{np(str)} + {prepnp(przez,acc)}
dzierżawić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
dzierżawić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
dziękować: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
dziękować: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
dziobać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
dziobać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
dziobać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
dziobać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
dziobać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
dziobać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
dziobać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dziobać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
dziwić: imperf: subj{cp(int)} + {np(str)}
dziwić: imperf: subj{np(str); cp(że); ncp(str,int); ncp(str,że)} + {np(str)}
dziwić: imperf: subj{np(str)} + {np(inst)} + {np(str)}
dziwić się: imperf: subj{np(str)} + {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: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
dzwonić: imperf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
dzwonić: imperf: subj{np(str)} + {np(dat)}
dzwonić: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
dzwonić: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
dzwonić: imperf: subj{np(str)} + {np(inst)}
dzwonić: imperf: subj{np(str)} + {preplexnp(do,gen,pl,'drzwi',atr)}
dzwonić: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'trwoga',natr)}
dzwonić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
dzwonić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
dzwonić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
dzwonić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
dzwonić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
dzwonić: imperf: subj{np(str)} + {prepnp(na,acc)}
dzwonić: imperf: subj{np(str)} + {prepnp(za,inst)}
dźwigać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
dźwigać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
dźwigać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
dźwigać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dźwigać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dźwigać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dźwigać się: imperf: subj{np(str)} + {prepnp(na,acc)}
dźwigać się: imperf: subj{np(str)} + {prepnp(na,loc)}
dźwigać się: imperf: subj{np(str)} + {prepnp(z,gen)}
dźwigać się: imperf: subj{np(str)} + {xp(abl)}
dźwignąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
dźwignąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
dźwignąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
dźwignąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
dźwignąć się: perf: subj{np(str)} + {prepnp(na,acc)}
dźwignąć się: perf: subj{np(str)} + {prepnp(na,loc)}
dźwignąć się: perf: subj{np(str)} + {prepnp(z,gen)}
dźwignąć się: perf: subj{np(str)} + {xp(abl)}
egzaminować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
egzaminować: imperf: subj{np(str)} + obj{np(str)} + {or}
egzaminować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
egzekwować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
eksperymentować: imperf: subj{np(str)} + {np(inst)}
eksperymentować: imperf: subj{np(str)} + {prepnp(na,loc)}
eksperymentować: imperf: subj{np(str)} + {prepnp(z,inst)}
eksploatować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
eksploatować: imperf: subj{np(str)} + {refl}
eksplodować: _: subj{np(str)} + {np(inst)}
eksplodować: _: subj{np(str)} + obj{np(str)}
eksponować: imperf: subj{np(str)} + {cp(że)}
eksponować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
eksportować: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
eliminować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
emanować: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
emanować: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
emanować: imperf: subj{np(str)} + {prepnp(od,gen)}
emanować: imperf: subj{np(str)} + {prepnp(z,gen)}
emitować: _: subj{np(str)} + obj{np(str)} + {xp(locat)}
ewakuować: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
ewakuować się: _: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
falować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
falować: imperf: subj{np(str)} + obj{np(str)}
fałszować: imperf: subj{np(str)} + {cp(że)}
fałszować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
farbować: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
farbować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
farbować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
farbować się: perf: subj{np(str)} + {advp(misc)}
farbować się: perf: subj{np(str)} + {np(inst)}
farbować się: perf: subj{np(str)} + {prepnp(na,acc)}
fascynować: imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(str)}
fascynować: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
fascynować się: imperf: subj{np(str)} + {cp(int)}
fascynować się: imperf: subj{np(str)} + {cp(że)}
fascynować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
fatygować: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
fatygować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
fatygować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
fatygować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
fatygować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
fatygować: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
fatygować się: imperf: subj,controller{np(str)} + controllee{infp(_)}
fatygować się: imperf: subj{np(str)} + {cp(żeby)}
fatygować się: imperf: subj{np(str)} + {np(inst)}
fatygować się: imperf: subj{np(str)} + {prepnp(do,gen)}
fatygować się: imperf: subj{np(str)} + {prepnp(na,acc)}
fatygować się: imperf: subj{np(str)} + {prepnp(z,inst)}
fatygować się: imperf: subj{np(str)} + {xp(adl)}
figurować: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {xp(locat)}
figurować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {xp(locat)}
finansować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
finansować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
flirtować: imperf: subj{np(str)} + {prepnp(z,inst)}
formować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
formować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
formować się: imperf: subj{np(str)} + {prepnp(w,acc)}
formować się: imperf: subj{np(str)} + {prepnp(z,gen)}
formułować: imperf: subj{np(str)} + controller{ncp(str,że)} + controllee{prepnp(jako,str)}
formułować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
formułować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
forsować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
forsować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
forsować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
forsować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
fotografować: imperf: subj{np(str)} + {np(inst)} + {refl}
fotografować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
fruwać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
fruwać: imperf: subj{np(str)} + {prepnp(na,loc)}
fundować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
fundować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
funkcjonować: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
funkcjonować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
funkcjonować: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
gadać: imperf: subj,controller{np(str)} + controllee{xp(mod)}
gadać: imperf: subj{np(str)} + {np(dat)} + {np(str)}
gadać: imperf: subj{np(str)} + {np(dat)} + {or}
gadać: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
gadać: imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
gadać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
gadać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
gadać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
gadać: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
gadać: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
gadać: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
gadać: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
gadać: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
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(dat)} + {np(inst)}
gasić: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'zarodek',natr)}
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)}
ginąć: imperf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,pl,'oko',natr)}
ginąć: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
ginąć: imperf: subj{np(str)} + {prepnp(na,loc)}
ginąć: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
ginąć: imperf: subj{np(str)} + {prepnp(w,loc)}
ginąć: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
ginąć: imperf: subj{np(str)} + {prepnp(z,gen)}
ginąć: imperf: subj{np(str)} + {xp(locat)}
gładzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
gładzić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gładzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
głaskać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
głaskać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
głaskać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
gł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)}
głowić się: imperf: subj{np(str)} + {cp(int)}
głowić się: imperf: subj{np(str)} + {or}
głowić się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
gnać: imperf: {np(str)} + {prepnp(do,gen)}
gnać: imperf: {np(str)} + {xp(abl)} + {xp(adl)}
gnać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
gnać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
gnać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
gnębić: imperf: subj{cp(int)} + {np(str)}
gnębić: imperf: subj{cp(że)} + {np(str)}
gnębić: imperf: subj{np(str); ncp(str,że)} + {np(str)}
gnębić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gnębić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
gnębić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
gnić: imperf: subj{np(str)} + {np(dat)} + {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: {np(str)} + {xp(locat)}
gnieść: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
gnieść: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gnieść się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
gniewać: imperf: subj{cp(że)} + {np(str)}
gniewać: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
gniewać się: imperf: subj{np(str)} + {comprepnp(z powodu)}
gniewać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)}
gniewać się: imperf: subj{np(str)} + {or}
gniewać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
gniewać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
gniewać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
gniewać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(z,inst)}
gniewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
gniewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
gnieździć się: imperf: subj{np(str)} + {prepnp(u,gen)}
gnieździć się: imperf: subj{np(str)} + {xp(locat)}
godzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
godzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
godzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
godzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
godzić: imperf: subj{np(str)} + {prepnp(na,acc)}
godzić się: imperf: {np(dat)} + {advp(pron)}
godzić się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
godzić się: imperf: subj,controller{np(str)} + controllee{infp(_)}
godzić się: imperf: subj{cp(żeby)} + {np(dat)}
godzić się: imperf: subj{np(str)} + {cp(że)}
godzić się: imperf: subj{np(str)} + {cp(żeby)}
godzić się: imperf: subj{np(str)} + {or}
godzić się: imperf: subj{np(str)} + {prepnp(do,gen)}
godzić się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
godzić się: imperf: subj{np(str)} + {prepnp(za,acc)}
godzić się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że); prepncp(z,inst,żeby)}
goić: imperf: subj{np(str)} + {np(str)}
goić się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
goić się: imperf: subj{np(str)} + controller{prepnp(na,loc)} + controllee{xp(mod)}
golić: imperf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
golić: imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
golić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {advp(misc)}
golić: imperf: subj{np(str)} + obj{np(str)} + {np(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)}
gorzeć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
gorzeć: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
gospodarować: imperf: subj{np(str)} + {np(inst)}
gospodarować: imperf: subj{np(str)} + {prepnp(na,loc)}
gospodarować: imperf: subj{np(str)} + {xp(locat)}
gościć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gościć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
gościć: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gotować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
gotować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
gotować się: imperf: subj{np(str)} + {comprepnp(z powodu)}
gotować się: imperf: subj{np(str)} + {cp(żeby)}
gotować się: imperf: subj{np(str)} + {prepnp(do,gen)}
gotować się: imperf: subj{np(str)} + {prepnp(na,acc)}
gotować się: imperf: subj{np(str)} + {prepnp(od,gen)}
gotować się: imperf: subj{np(str)} + {prepnp(w,loc)}
gotować się: imperf: subj{np(str)} + {xp(locat)}
górować: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(nad,inst)}
grać: imperf: subj{np(str)} + {comprepnp(na rzecz)}
grać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
grać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {prepnp(z,inst)}
grać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
grać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); prepnp(w,loc); xp(locat)}
grać: imperf: subj{np(str)} + {prepnp(do,gen)}
grać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
grać: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)}
graniczyć: imperf: subj{np(str)} + {prepnp(z,inst)}
grasować: imperf: subj{np(str)} + {xp(locat)}
gratulować: imperf: subj{np(str)} + {np(dat)} + {np(gen); cp(że); ncp(gen,że)}
gromadzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
gromadzić: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gromadzić się: imperf: subj{np(str)} + {prepnp(u,gen)}
gromadzić się: imperf: subj{np(str)} + {xp(locat)}
grozić: imperf: subj{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)}
gruchnąć: perf: subj{cp(że)} + {xp(locat)}
gruchnąć: perf: subj{np(str)} + {cp(że)}
gruchnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
gruchnąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
gruchnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
gruchnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
gruchnąć: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
gruchnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
gruchnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
gruchnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
gruchnąć: perf: subj{np(str)} + {prepnp(na,acc)}
gruchnąć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
gruchnąć: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
gruchnąć: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
gruchnąć: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
gruchnąć: perf: subj{or} + {xp(abl)}
gruchnąć: perf: subj{or} + {xp(locat)}
gryźć: imperf: subj{cp(int)} + {np(str)}
gryźć: imperf: subj{cp(że)} + {np(str)}
gryźć: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
gryźć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gryźć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
gryźć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
gryźć: imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
gryźć: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
gryźć się: imperf: subj{np(str)} + {cp(int)}
gryźć się: imperf: subj{np(str)} + {cp(że)}
gryźć się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
gryźć się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
grzać: imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
grzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
grzać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
grzać się: imperf: subj{np(str)} + {np(inst)}
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)} + {preplexnp(z,gen,pl,'oko',natr)}
gubić: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
gubić się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
gubić się: imperf: subj{np(str)} + {np(inst)}
gubić się: imperf: subj{np(str)} + {prepnp(w,loc)}
gustować: imperf: subj{np(str)} + {prepnp(w,loc)}
gwałcić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
gwarantować: imperf: subj{np(str); ncp(str,że)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
gwarantować: imperf: subj{np(str)} + {or}
gwizdać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
gwizdać: imperf: subj{np(str)} + {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); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
hamować: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
hamować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
hamować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
hamować: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
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)}
hodować się: imperf: subj{np(str)} + {advp(misc)}
huczeć: imperf: {np(dat)} + {xp(locat)}
huczeć: imperf: {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {xp(locat)}
huczeć: imperf: {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
huczeć: imperf: subj{cp(int)} + {xp(locat)}
huczeć: imperf: subj{cp(że)} + {xp(locat)}
huczeć: imperf: subj{np(str)} + {cp(int)}
huczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
huczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
huczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
huczeć: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
huczeć: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
huknąć: perf: subj{cp(że)} + {xp(locat)}
huknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
huknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
huknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
huknąć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
huknąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
huknąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
huknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
huknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
huknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
huknąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
huknąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
hulać: imperf: subj{np(str)} + {prepnp(w,loc)}
hulać: imperf: subj{np(str)} + {prepnp(za,acc)}
hulać: imperf: subj{np(str)} + {xp(locat)}
hulać: imperf: subj{np(str)} + {xp(perl)}
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)}
identyfikować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
identyfikować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
identyfikować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
identyfikować się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,nom)}
identyfikować się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
ignorować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
ilustrować: imperf: subj{np(str)} + {cp(int); cp(że)}
ilustrować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
imać się: imperf: subj{np(str)} + {np(gen)}
importować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
importować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
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)}
inspirować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
inspirować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
inspirować się: imperf: subj{np(str)} + {np(inst)}
instalować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
instalować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
instalować się: imperf: subj{np(str)} + {prepnp(u,gen)}
instalować się: imperf: subj{np(str)} + {xp(locat)}
interesować: imperf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(str)}
interesować się: imperf: subj{np(str)} + {cp(int)}
interesować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
interweniować: imperf: subj{np(str)} + {comprepnp(na temat)} + {xp(locat)}
interweniować: imperf: subj{np(str)} + {comprepnp(w kwestii)} + {xp(locat)}
interweniować: imperf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
interweniować: imperf: subj{np(str)} + {np(inst)}
interweniować: imperf: subj{np(str)} + {prepncp(o,acc,żeby)} + {xp(locat)}
interweniować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
interweniować: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(u,gen)}
interweniować: imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(u,gen); xp(locat)} + {comprepnp(w sprawie)}
interweniować: imperf: subj{np(str)} + {prepnp(przy,loc)}
interweniować: imperf: subj{np(str)} + {prepnp(u,gen)} + {comprepnp(na temat)}
interweniować: imperf: subj{np(str)} + {prepnp(u,gen)} + {cp(że)}
interweniować: imperf: subj{np(str)} + {prepnp(u,gen)} + {or}
interweniować: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepncp(o,acc,żeby)}
interweniować: imperf: subj{np(str)} + {prepnp(w,acc)}
inwestować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
irytować: imperf: subj{cp(gdy)} + {np(str)}
irytować: imperf: subj{cp(jak)} + {np(str)}
irytować: imperf: subj{cp(jeśli)} + {np(str)}
irytować: imperf: subj{cp(kiedy)} + {np(str)}
irytować: imperf: subj{cp(że)} + {np(str)}
irytować: imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(str)}
irytować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
irytować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
irytować się: imperf: subj{np(str)} + {or}
irytować się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
istnieć: imperf: subj{np(str)} + {prepnp(dla,gen)}
istnieć: imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
istnieć: imperf: subj{np(str)} + {xp(locat)} + {xp(temp)}
iść: imperf: {infp(_)}
iść: imperf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
iść: imperf: {np(dat)} + {xp(mod)}
iść: imperf: {prepadjp(ku,dat)}
iść: imperf: {prepnp(ku,dat); prepncp(ku,dat,że)}
iść: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
iść: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
iść: imperf: subj{np(str)} + {cp(że)} + {preplexnp(o,acc,sg,'głowa',natr)}
iść: imperf: subj{np(str)} + {cp(że)} + {preplexnp(o,acc,sg,'zakład',natr)}
iść: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ręka',natr)}
iść: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
iść: imperf: subj{np(str)} + {preplexnp(w,acc,pl,'ślad',ratr)}
iść: imperf: subj{np(str)} + {preplexnp(z,inst,pl,'torba',natr)}
iść: imperf: subj{np(str)} + {preplexnp(z,inst,sg,'dym',natr)}
iść: imperf: subj{np(str)} + {prepnp(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}
jadać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
jadać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
jadać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
jadać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
jaśnieć: imperf: subj{E} + {xp(locat)}
jaśnieć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
jaśnieć: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
jawić się: imperf: subj,controller{np(str)} + controllee{adjp(str)} + {np(dat)}
jawić się: imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
jawić się: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
jawić się: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(przed,inst)}
jawić się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(przed,inst,pl,'oko',natr)}
jawić się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(przed,inst)}
jawić się: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
jawić się: imperf: subj{np(str)} + {xp(locat)}
jąć: perf: subj,controller{E} + controllee{infp(imperf)}
jąć się: perf: subj{np(str)} + {np(gen)}
jechać: imperf: {np(inst)} + {prepnp(od,gen)}
jechać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
jechać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
jechać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
jechać: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
jechać: imperf: subj{np(str)} + {prepnp(na,loc)}
jechać: imperf: subj{np(str)} + {prepnp(po,loc)}
jechać: imperf: subj{np(str)} + {prepnp(z,inst)} + {fixed('na jednym wózku')}
jednoczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
jednoczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
jednoczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
jednoczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
jednoczyć się: imperf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
jednoczyć się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
jednoczyć się: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
jednoczyć się: imperf: subj{np(str)} + {prepnp(wokół,gen)}
jeść: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
jeść: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
jeść: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
jeść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
jeść: imperf: subj{np(str)} + {prepnp(za,acc)}
jeździć: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
jeździć: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
jeździć: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
jeździć: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
jeździć: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
jeździć: imperf: subj{np(str)} + {prepnp(na,loc)}
kaleczyć: imperf: subj{np(str)} + {np(inst)} + {refl}
kaleczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kaleczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
kaleczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kaleczyć się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kaleczyć się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
kalkulować: imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
kalkulować: imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
kalkulować: imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
kalkulować: imperf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
kalkulować: imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
kalkulować się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
kalkulować się: imperf: subj{cp(żeby)} + {np(dat)}
kalkulować się: imperf: subj{np(str)} + {advp(misc)}
kalkulować się: imperf: subj{np(str)} + {np(dat)}
kandydować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
kandydować: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
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)} + controllee{infp(_)}
kazać: _: subj{np(str)} + controller{np(dat)} + controllee{cp(żeby); infp(_)}
kazać: _: subj{np(str)} + {np(dat)} + {np(str)}
kazać: _: subj{np(str)} + {np(dat)} + {or}
kazić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kazić się: imperf: subj{np(str)} + {prepnp(z,inst)}
kąpać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kąpać: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
kąpać się: imperf: subj{np(str)} + {prepnp(w,loc)}
kibicować: imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
kibicować: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
kibicować: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
kichać: imperf: subj{np(str)} + {np(inst)}
kichać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
kichać się: imperf: subj{np(str)} + {prepnp(z,inst)}
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(do,gen); xp(adl)}
kierować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
kierować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
kierować się: imperf: subj{np(str)} + {prepnp(ku,dat)}
kierować się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
kierować się: imperf: subj{np(str)} + {xp(adl)}
kipieć: imperf: subj{E} + {prepnp(od,gen)} + {xp(locat)}
kipieć: imperf: subj{E} + {prepnp(w,loc)} + {prepnp(z,gen)}
kipieć: imperf: subj{np(str)} + {np(inst)}
kipieć: imperf: subj{np(str)} + {prepnp(od,gen)}
kipieć: imperf: subj{np(str)} + {prepnp(z,gen)}
kipieć: imperf: subj{np(str)} + {xp(abl)}
kipieć: imperf: subj{np(str)} + {xp(adl)}
kiwać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
kiwać: imperf: subj{np(str)} + obj{np(str)}
kiwać się: imperf: subj{np(str)} + {prepnp(od,gen)}
kiwnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
kiwnąć: perf: subj{np(str)} + obj{np(str)}
kiwnąć się: perf: subj{np(str)}
klaskać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
klaskać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klaskać: imperf: subj{np(str)} + {prepnp(na,acc)}
kląć: imperf: subj,controller{np(str)} + controllee{xp(mod)}
kląć: imperf: subj{np(str)} + {np(str)} + {cp(że)}
kląć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
kląć się: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
kląć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
klepać: imperf: subj,controller{np(str)} + controllee{xp(mod)}
klepać: imperf: subj{np(str)} + {comprepnp(na temat)}
klepać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klepać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
klepać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
klepać: imperf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
klepać: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(do,gen)}
klepać: imperf: subj{np(str)} + obj{cp(że); cp(żeby)} + {np(dat)}
klepać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
klepać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
klepać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klepać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
klepać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
klepać: imperf: subj{np(str)} + obj{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {np(dat)}
klepać: imperf: subj{np(str)} + obj{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(do,gen)}
klepać: imperf: subj{np(str)} + {or}
klepnąć: perf: subj,controller{np(str)} + controllee{xp(mod)}
klepnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
klepnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
klepnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
klepnąć: perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
klepnąć: perf: subj{np(str)} + obj{cp(że); cp(żeby)} + {np(dat)}
klepnąć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
klepnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
klepnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klepnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
klepnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
klepnąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
klepnąć: perf: subj{np(str)} + {or}
klęczeć: imperf: subj{np(str)} + {prepnp(przed,inst)}
klęczeć: imperf: subj{np(str)} + {xp(locat)}
klikać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
klikać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
klikać: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
klikać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
klikać: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
kliknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kliknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kliknąć: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
kliknąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
kluczyć: imperf: subj{np(str)} + {comprepnp(co do)}
kluczyć: imperf: subj{np(str)} + {comprepnp(na temat)}
kluczyć: imperf: subj{np(str)} + {comprepnp(w kwestii)}
kluczyć: imperf: subj{np(str)} + {comprepnp(w sprawie)}
kluczyć: imperf: subj{np(str)} + {cp(że)}
kluczyć: imperf: subj{np(str)} + {or}
kluczyć: imperf: subj{np(str)} + {prepnp(o,loc)}
kluczyć: imperf: subj{np(str)} + {prepnp(za,inst)}
kluczyć: imperf: subj{np(str)} + {xp(adl)}
kluczyć: imperf: subj{np(str)} + {xp(locat)}
kluczyć: imperf: subj{np(str)} + {xp(perl)}
kłamać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
kłamać: imperf: subj{np(str)} + {or}
kłamać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
kłamać: imperf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
kłaniać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(od,gen)}
kłaniać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,sg,'pas',natr)}
kłaniać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
kłaść: imperf: subj{np(str)} + {lexnp(str,pl,'ucho',natr)} + {preplexnp(po,loc,_,'siebie',natr)}
kłaść: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(w,acc,pl,'ucho',natr)}
kłaść: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(w,acc,pl,'ucho',natr)}
kłaść: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'ucho',natr)} + {or}
kłaść: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
kłaść: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {preplexnp(w,acc,pl,'ucho',natr)}
kłaść: imperf: subj{np(str)} + obj{lexnp(str,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)} + controllee{infp(imperf)}
kłaść się: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
kłaść się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
kłaść się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
kłaść się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
kłębić się: imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)} + {or}
kłębić się: imperf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
kłębić się: imperf: {prepnp(od,gen)} + {xp(locat)}
kłębić się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
kłębić się: imperf: subj{np(str)} + {prepnp(od,gen)}
kłębić się: imperf: subj{np(str)} + {xp(locat)}
kłócić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kłócić się: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
kłócić się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
kłócić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
kłuć: imperf: {np(str)} + {xp(locat)}
kłuć: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
kłuć: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
kłuć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
kłuć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kochać: imperf: subj,controller{np(str)} + controllee{infp(_)}
kochać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
kochać się: imperf: subj{np(str)} + {prepnp(w,loc)}
kochać się: imperf: subj{np(str)} + {prepnp(z,inst)}
koczować: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
kojarzyć: imperf: subj{np(str)} + {cp(int); cp(że)}
kojarzyć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
kojarzyć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
kojarzyć: imperf: subj{np(str)} + obj{np(str); ncp(str,ż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)} + controllee{prepadjp(jako,str)} + {np(dat)}
kojarzyć się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
kojarzyć się: imperf: subj{cp(jak)} + {np(dat)} + {advp(misc)}
kojarzyć się: imperf: subj{cp(że)} + {np(dat)}
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)}
kolekcjonować: imperf: subj{np(str)} + obj{np(str)}
kolidować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
kołysać: imperf: subj{np(str)} + {np(inst)}
kołysać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kołysać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
kołysać się: imperf: subj{np(str)} + {prepnp(na,loc)}
kołysać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
kołysać się: imperf: subj{np(str)} + {xp(locat)}
kombinować: imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)}
kombinować: imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
kombinować: imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
kombinować: imperf: subj{np(str)} + {lexnp(dat,_,'siebie',natr)} + {or}
kombinować: imperf: subj{np(str)} + obj{np(str)} + {lexnp(dat,_,'siebie',natr)}
kombinować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
kombinować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
kombinować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
kombinować: imperf: subj{np(str)} + {prepnp(przy,loc)} + {nonch}
komentować: imperf: subj{np(str)} + obj{np(str)} + {or}
kompletować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
kompletować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kompletować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
kompletować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
komplikować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
komplikować się: imperf: subj{np(str)}
komunikować: imperf: subj{np(str)} + {np(dat)} + {or}
komunikować: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
komunikować: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
komunikować: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
komunikować się: imperf: subj{np(str)} + {prepnp(z,inst)}
konać: imperf: subj{np(str)} + {prepnp(na,acc)}
konać: imperf: subj{np(str)} + {prepnp(od,gen)}
konać: imperf: subj{np(str)} + {prepnp(wskutek,gen)}
konać: imperf: subj{np(str)} + {prepnp(z,gen)}
koncentrować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
koncentrować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
koncentrować się: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
koncentrować się: imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że); prepncp(wokół,gen,żeby)}
koncentrować się: imperf: subj{np(str)} + {xp(locat)}
koncertować: imperf: subj{np(str)} + {xp(locat)}
konkurować: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
konkurować: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
konkurować: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
konstruować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
konsultować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst)}
konsultować się: imperf: subj{np(str)} + {prepnp(z,inst)}
kontaktować: imperf: subj{np(str)}
kontaktować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kontaktować się: imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)} + {comprepnp(na temat)}
kontaktować się: imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
kontemplować: imperf: subj{np(str)} + {cp(int)}
kontemplować: imperf: subj{np(str)} + {cp(że)}
kontemplować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
kontemplować: imperf: subj{np(str)} + {or}
kontrolować: imperf: subj{np(str)} + {cp(int)} + {refl}
kontrolować: imperf: subj{np(str)} + {cp(że)}
kontrolować: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
kontrolować: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
kontrolować: imperf: subj{np(str)} + {refl}
kontynuować: imperf: subj{np(str)} + obj{np(str)} + {or}
kończyć: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
kończyć: imperf: subj,controller{np(str)} + controllee{xp(mod)}
kończyć: imperf: subj{np(str)} + {np(str)}
kończyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kończyć: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
kończyć: imperf: subj{np(str)} + {prepnp(z,inst)}
kończyć: imperf: subj{np(str)} + {xp(locat)}
kończyć się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
kończyć się: imperf: subj{np(str)} + {np(inst)}
kończyć się: imperf: subj{np(str)} + {prepnp(na,acc)}
kończyć się: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
koordynować: imperf: subj{np(str)} + {np(inst)}
koordynować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
kopać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
kopać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
kopać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
kopać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc); prepnp(w,acc)}
kopać się: imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)}
kopać się: imperf: subj{np(str)} + {xp(adl)}
kopiować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
korcić: imperf: controller{np(str)} + controllee{infp(_)}
korcić: imperf: {np(str)} + {cp(że)}
korcić: imperf: {np(str)} + {cp(żeby)}
korcić: imperf: {np(str)} + {prepnp(do,gen)}
korcić: imperf: {np(str)} + {prepnp(na,acc)}
korcić: imperf: subj{np(str); ncp(str,że)} + {np(str)}
korespondować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)} + {advp(misc)}
korespondować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
korespondować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
korespondować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
korzystać: imperf: subj{np(str)} + {cp(że)}
korzystać: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
korzystać: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
kosztować: imperf: subj{np(str)} + {np(str)} + {np(str)}
kosztować: imperf: subj{np(str)} + obj{np(part)}
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)}
kreślić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
kręcić: imperf: subj{np(str)} + {np(dat)} + {np(str)}
kręcić: imperf: subj{np(str)} + {np(inst)} + {or}
kręcić: imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
kręcić się: imperf: {np(dat)} + {preplexnp(w,loc,sg,'głowa',atr)}
kręcić się: imperf: subj{np(str)} + {np(dat)}
kręcić się: imperf: subj{np(str)} + {prepnp(koło,gen)}
kręcić się: imperf: subj{np(str)} + {prepnp(przy,loc)}
kręcić się: imperf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że); prepncp(wokół,gen,żeby)}
kręcić się: imperf: subj{np(str)} + {prepnp(za,inst)}
kręcić się: imperf: subj{np(str)} + {xp(locat)}
krępować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
krępować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
krępować się: imperf: subj{np(str)} + {cp(że)}
krępować się: imperf: subj{np(str)} + {infp(_)}
krępować się: imperf: subj{np(str)} + {np(gen); ncp(gen,że)}
krępować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
krępować się: imperf: subj{np(str)} + {prepnp(w,loc)}
kroczyć: imperf: subj{np(str)} + {prepnp(do,gen)}
kroczyć: imperf: subj{np(str)} + {prepnp(ku,dat)}
kroczyć: imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
kroić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
kroić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
kroić się: imperf: subj{np(str)} + {np(dat)}
kropić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kropić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
kropić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
kropić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
kropić: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
królować: imperf: subj{np(str)} + {np(dat)}
królować: imperf: subj{np(str)} + {prepnp(nad,inst)}
królować: imperf: subj{np(str)} + {xp(locat)}
kruszyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kruszyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kruszyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kruszyć: imperf: subj{np(str)} + {prepncp(o,acc,int)} + {lexnp(str,_,'kopia',natr)}
kruszyć: imperf: subj{np(str)} + {prepncp(o,acc,żeby)} + {lexnp(str,_,'kopia',natr)}
kruszyć: imperf: subj{np(str)} + {prepncp(o,acc,że)} + {lexnp(str,_,'kopia',natr)}
kruszyć: imperf: subj{np(str)} + {prepnp(o,acc)} + {lexnp(str,_,'kopia',natr)}
kruszyć się: imperf: subj{np(str)} + {prepnp(na,acc)}
kruszyć się: imperf: subj{np(str)} + {prepnp(od,gen)}
kruszyć się: imperf: subj{np(str)} + {prepnp(pod,inst)}
krwawić: imperf: subj{lexnp(str,_,'serce',ratr)} + {comprepnp(z powodu)}
krwawić: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {comprepnp(z powodu)}
krwawić: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(gdy)}
krwawić: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(jak)}
krwawić: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(jeśli)}
krwawić: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(kiedy)}
krwawić: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {cp(że)}
krwawić: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {prepnp(z,gen)}
krwawić: imperf: subj{lexnp(str,sg,'serce',ratr)} + {cp(gdy)}
krwawić: imperf: subj{lexnp(str,sg,'serce',ratr)} + {cp(jak)}
krwawić: imperf: subj{lexnp(str,sg,'serce',ratr)} + {cp(kiedy)}
krwawić: imperf: subj{lexnp(str,sg,'serce',ratr)} + {cp(że)}
krwawić: imperf: subj{lexnp(str,sg,'serce',ratr)} + {prepnp(z,gen)}
krwawić: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
krwawić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
krwawić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
krwawić: imperf: subj{np(str)} + {xp(adl)}
krwawić: imperf: subj{np(str)} + {xp(perl)}
krwawić się: imperf: subj{lexnp(str,sg,'serce',natr)} + {cp(jak)}
krwawić się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'serce',natr)}
krwawić się: imperf: subj{np(str)} + {np(inst)}
kryć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
kryć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
kryć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kryć: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
kryć się: perf: subj{np(str)} + {prepnp(pod,inst)}
kryć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
kryć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
kryć się: perf: subj{np(str)} + {prepnp(w,loc)}
kryć się: perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
krytykować: imperf: subj{np(str)} + {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)}
krzątać się: imperf: subj{np(str)} + {prepnp(koło,gen)}
krzątać się: imperf: subj{np(str)} + {prepnp(przy,loc)}
krzątać się: imperf: subj{np(str)} + {prepnp(wokół,gen)}
krzątać się: imperf: subj{np(str)} + {xp(locat)}
krzyczeć: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
krzyczeć: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
krzyczeć: imperf: subj{np(str)} + {np(dat)} + {np(str)}
krzyczeć: imperf: subj{np(str)} + {np(str); cp(że); cp(żeby)} + {prepnp(do,gen)}
krzyczeć: imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc)}
krzyczeć: imperf: subj{np(str)} + {np(str)} + {prepnp(za,inst)}
krzyczeć: imperf: subj{np(str)} + obj{or} + {np(dat)}
krzyczeć: imperf: subj{np(str)} + obj{or} + {prepnp(do,gen)}
krzyczeć: imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
krzyczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
krzyczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
krzyczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
krzyczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {nonch}
krzyczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
krzyczeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
krzyczeć: imperf: subj{np(str)} + {prepnp(o,acc)}
krzyczeć: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
krzyczeć: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
krzyczeć: imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
krzyczeć: imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
krzyczeć: imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
krzyczeć: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
krzyknąć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
krzyknąć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
krzyknąć: perf: subj{np(str)} + {np(dat)} + {or}
krzyknąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
krzyknąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
krzyknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
krzyknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
krzyknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
krzyknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); cp(żeby)}
krzyknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
krzyknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
krzyknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
krzyknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
krzyknąć: perf: subj{np(str)} + {prepnp(o,acc)}
krzyknąć: perf: subj{np(str)} + {prepnp(o,loc)}
krzyknąć: perf: subj{np(str)} + {prepnp(przeciw,dat)}
krzyknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
krzyknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
krzyknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {or}
krzyknąć: perf: subj{np(str)} + {prepnp(z,gen)} + {or}
krzyżować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
krzyżować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
krzyżować się: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
kształcić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
kształcić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
kształcić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
kształcić się: imperf: subj{np(str)} + {prepnp(na,acc)}
kształcić się: imperf: subj{np(str)} + {prepnp(na,loc)}
kształcić się: imperf: subj{np(str)} + {prepnp(w,loc)}
kształtować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
kształtować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
kształtować się: imperf: subj{np(str)} + {np(inst)}
kształtować się: imperf: subj{np(str)} + {xp(locat)}
kultywować: imperf: subj{np(str)} + obj{np(str)}
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)}
kursować: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
kursować: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
kursować: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
kusić: imperf: subj{cp(żeby)} + {np(str)}
kusić: imperf: subj{np(str)} + {cp(że)}
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)} + controllee{infp(_)}
kusić się: imperf: subj{np(str)} + {prepnp(na,acc)}
kusić się: imperf: subj{np(str)} + {prepnp(o,acc)}
kwapić się: imperf: subj,controller{np(str)} + controllee{infp(_)}
kwapić się: imperf: subj{np(str)} + {cp(żeby)}
kwapić się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
kwapić się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
kwapić się: imperf: subj{np(str)} + {xp(adl)}
kwestionować: imperf: subj{np(str)} + {cp(jakoby)}
kwestionować: imperf: subj{np(str)} + obj{cp(int)}
kwestionować: imperf: subj{np(str)} + obj{cp(że)}
kwestionować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
kwestować: imperf: subj{np(str)} + {prepnp(na,acc)}
kwitnąć: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
kwitnąć: imperf: subj{np(str)} + {prepnp(w,loc)}
lać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
lać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
lać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
lać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
lać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
lać się: imperf: {np(dat)} + {preplexnp(na,acc,pl,'głowa',natr)}
lać się: imperf: {np(dat)} + {xp(abl)}
lać się: imperf: {np(inst)} + {prepnp(z,gen)}
lać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
lać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
lać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,pl,'głowa',natr)}
lać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(przez,acc,pl,'ręka',natr)}
lać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
lać się: imperf: subj{np(str)} + {xp(adl)}
lać się: imperf: subj{np(str)} + {xp(locat)}
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)}
lądować: imperf: subj{np(str)} + {advp(misc)}
lądować: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
lądować: imperf: subj{np(str)} + {xp(locat)}
lecieć: imperf: {np(dat)} + {advp(misc)}
lecieć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
lecieć: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
lecieć: imperf: subj{np(str)} + {prepnp(do,gen)}
lecieć: imperf: subj{np(str)} + {prepnp(na,acc)}
lecieć: imperf: subj{np(str)} + {prepnp(na,loc)}
lecieć: imperf: subj{np(str)} + {prepnp(za,inst)}
lecieć: imperf: subj{np(str)} + {prepnp(z,gen)}
leczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
leczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
leczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
leczyć się: imperf: subj{np(str)} + {np(dat)}
leczyć się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
leczyć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen)}
leczyć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(locat)}
leczyć się: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen)}
leczyć się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
leczyć się: imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
lekceważyć: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
lenić: imperf: subj{np(str)} + obj{np(str)}
lenić się: imperf: subj,controller{np(str)} + controllee{infp(_)}
lenić się: imperf: subj{np(str)} + {prepnp(do,gen)}
lenić się: imperf: subj{np(str)} + {prepnp(z,inst)}
lenić się: imperf: subj{np(str)} + {xp(locat)}
lenić się: imperf: subj{np(str)} + {xp(temp)}
lepić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
lepić: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
lepić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
lepić się: imperf: subj{np(str)} + {prepnp(od,gen)}
lepić się: imperf: subj{np(str)} + {prepnp(z,gen)}
leżeć: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(na,loc)}
leżeć: imperf: subj{np(str); ncp(str,żeby)} + {prepnp(w,loc)}
leżeć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
leżeć: imperf: subj{np(str)} + {prepnp(u,gen)}
leżeć: imperf: subj{np(str)} + {xp(locat)}
lękać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
lękać się: imperf: subj{np(str)} + {cp(czy)}
lękać się: imperf: subj{np(str)} + {cp(że)}
lękać się: imperf: subj{np(str)} + {cp(żeby)}
lękać się: imperf: subj{np(str)} + {np(gen); ncp(str,że); ncp(str,żeby)}
lękać się: imperf: subj{np(str)} + {prepncp(o,acc,czy)}
lękać się: imperf: subj{np(str)} + {prepncp(o,acc,że)}
lękać się: imperf: subj{np(str)} + {prepnp(o,acc)}
lgnąć: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
lgnąć: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
lgnąć: imperf: subj{np(str)} + {prepnp(w,loc)}
liczyć: imperf: subj{np(str)} + {np(str)}
liczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
liczyć: imperf: subj{np(str)} + {prepnp(do,gen)}
liczyć: imperf: subj{np(str)} + {prepnp(na,acc); cp(że); prepncp(na,acc,że)}
liczyć się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
likwidować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
likwidować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
likwidować: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
lokować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
lokować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
lokować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
lokować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
lokować się: imperf: subj{np(str)} + {prepnp(u,gen)}
lokować się: imperf: subj{np(str)} + {xp(locat)}
lubić: imperf: subj,controller{np(str)} + controllee{np(str); cp(gdy); cp(jak); cp(jeśli); cp(kiedy); cp(że); cp(żeby); ncp(str,int); ncp(str,jak); ncp(str,że); infp(_)}
lubić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
lubić się: imperf: subj{np(str)} + {prepnp(z,inst)}
ł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)}
łagodzić: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
łamać: imperf: {np(str)} + {prepnp(w,loc)}
łamać: imperf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
łamać: imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
łamać: imperf: subj{np(str)} + {cp(że)} + {lexnp(str,pl,'ręka',natr)}
łamać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)} + {or}
łamać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
łamać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
łamać: imperf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,pl,'ręka',natr)}
łamać: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
łamać: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'ząb',atr)}
łamać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
łamać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
łamać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
łamać się: imperf: subj{np(str)} + {prepnp(na,loc)}
łamać się: imperf: subj{np(str)} + {prepnp(o,acc)}
łamać się: imperf: subj{np(str)} + {prepnp(w,loc)}
łatać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
łazić: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
łazić: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
łazić: imperf: subj{cp(żeby)} + {prepnp(za,inst)}
łazić: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(po,loc,sg,'głowa',natr)}
łazić: imperf: subj{cp(że)} + {prepnp(za,inst)}
łazić: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
łazić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
łazić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
łazić: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {xp(abl)} + {xp(perl)}
łazić: imperf: subj{np(str)} + {prepnp(koło,gen)}
łazić: imperf: subj{np(str)} + {prepnp(na,acc); xp(adl)}
łazić: imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
łazić: imperf: subj{np(str)} + {prepnp(w,loc)}
łazić: imperf: subj{np(str)} + {prepnp(za,inst)}
łazić: imperf: subj{np(str)} + {prepnp(z,inst)}
łą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)}
łykać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
łykać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
łyknąć: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
łyknąć: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
łyknąć: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
machać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
machać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
machać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
machać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
machać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
machać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
machać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
machać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
machać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
machać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
machać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(inst,sg,'ręka',natr)}
machnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
machnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
machnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
machnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
machnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
machnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
machnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
machnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
machnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
machnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
machnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
machnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
machnąć: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {lexnp(inst,sg,'ręka',natr)}
machnąć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
machnąć się: perf: subj{np(str)} + {prepnp(za,acc)}
machnąć się: perf: subj{np(str)} + {xp(adl)}
majaczyć: imperf: subj{cp(że)} + {np(dat)}
majaczyć: imperf: subj{np(str)} + {cp(że)}
majaczyć: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
majaczyć: imperf: subj{np(str)} + {np(str)}
majaczyć: imperf: subj{or} + {np(dat)}
majaczyć się: imperf: subj{cp(jakby)} + {np(dat)}
majaczyć się: imperf: subj{cp(że)} + {np(dat)}
majaczyć się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
majaczyć się: imperf: subj{or} + {np(dat)}
majstrować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przy,loc)}
majstrować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
majstrować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
majstrować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
majstrować: imperf: subj{np(str)} + {prepnp(nad,inst)}
malować: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
malować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
malować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
malować się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
malować się: imperf: subj{np(str)} + {prepnp(w,loc)}
manipulować: imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
marnować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
marnować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,_,'siebie',natr)}
marnować się: imperf: subj{np(str)}
marszczyć: imperf: subj{np(str)} + obj{np(str)}
marszczyć się: imperf: subj{np(str)} + {np(dat)}
marszczyć się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
marszczyć się: imperf: subj{np(str)} + {xp(locat)}
martwić: imperf: subj{cp(int)} + {np(str)}
martwić: imperf: subj{cp(że)} + {np(str)}
martwić: imperf: subj{np(str)} + {np(inst)} + {np(str)}
martwić się: imperf: subj{np(str)} + {comprepnp(z powodu)}
martwić się: imperf: subj{np(str)} + {cp(int)}
martwić się: imperf: subj{np(str)} + {cp(że)}
martwić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
martwić się: imperf: subj{np(str)} + {or}
martwić się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
marznąć: imperf: subj{np(str)} + {fixed('do szpiku kości')}
marznąć: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
marznąć: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'kość',natr)}
marznąć: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'sopel',natr)}
marzyć: imperf: subj,controller{np(str)} + controllee{infp(_)}
marzyć: imperf: subj{np(str)} + {cp(że)}
marzyć: imperf: subj{np(str)} + {or}
marzyć: imperf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
marzyć się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
marzyć się: imperf: subj{cp(żeby)} + {np(dat)}
marzyć się: imperf: subj{cp(że)} + {np(dat)}
marzyć się: imperf: subj{np(str)} + {np(dat)}
masować: imperf: subj{np(str)} + {np(inst)} + {refl}
masować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
masować: imperf: subj{np(str)} + {prepnp(po,loc)} + {refl}
maszerować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
maszerować: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
maszerować: imperf: subj{np(str)} + {xp(perl)}
mawiać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{np(nom)}
mawiać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
mawiać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {or}
mawiać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
mawiać: imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
mdleć: imperf: subj{lexnp(str,sg,'serce',natr)} + {prepnp(w,loc)}
mdleć: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
mdleć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
medytować: imperf: subj{np(str)} + {cp(int)}
medytować: imperf: subj{np(str)} + {or}
medytować: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
medytować: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
meldować: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
meldować: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
meldować: imperf: subj{np(str)} + {np(dat)} + {or}
meldować: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
meldować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
meldować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
meldować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
meldować: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
meldować: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
meldować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
meldować się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
meldować się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
meldować się: imperf: subj{np(str)} + {prepnp(na,acc)}
meldować się: imperf: subj{np(str)} + {prepnp(u,gen)}
męczyć: imperf: subj{cp(kiedy)} + {np(str)}
męczyć: imperf: subj{cp(że)} + {np(str)}
męczyć: imperf: subj{np(str); ncp(str,że)} + {np(str)}
męczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
męczyć się: imperf: subj{np(str)} + {cp(że)}
męczyć się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
męczyć się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,żeby)}
męczyć się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
mianować: _: subj,controller{np(str)} + controllee{np(inst)} + {refl}
mianować: _: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
mianować: _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mianować: _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
mianować: _: subj{np(str)} + {prepnp(na,acc)} + {refl}
mieć: imperf: subj,controller{E} + controllee{infp(_)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,_,'ambicja',atr); lexnp(str,_,'możliwość',atr); lexnp(str,_,'podstawa',atr); lexnp(str,_,'powód',atr); lexnp(str,_,'szansa',atr); lexnp(str,sg,'chęć',atr); lexnp(str,sg,'cierpliwość',atr); lexnp(str,sg,'czas',atr); lexnp(str,sg,'czelność',atr); lexnp(str,sg,'fantazja',atr); lexnp(str,sg,'interes',atr); lexnp(str,sg,'kaprys',atr); lexnp(str,sg,'możność',atr); lexnp(str,sg,'nadzieja',atr); lexnp(str,sg,'nieszczęście',atr); lexnp(str,sg,'obowiązek',atr); lexnp(str,sg,'ochota',atr); lexnp(str,sg,'odwaga',atr); lexnp(str,sg,'okazja',atr); lexnp(str,sg,'pragnienie',atr); lexnp(str,sg,'prawo',atr); lexnp(str,sg,'przyjemność',atr); lexnp(str,sg,'serce',atr); lexnp(str,sg,'siła',atr); lexnp(str,sg,'sposobność',atr); lexnp(str,sg,'sumienie',atr); lexnp(str,sg,'szczęście',atr); lexnp(str,sg,'zamiar',atr); lexnp(str,sg,'zaszczyt',atr); lexnp(str,sg,'zdrowie',atr); lexnp(str,sg,'zwyczaj',atr); lexnp(str,sg,'śmiałość',atr)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,_,'przyczyna',atr)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'obyczaj',atr)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'pech',atr)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'polecenie',natr)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'rozkaz',natr)}
mieć: imperf: subj,controller{np(str)} + controllee{infp(_)} + {lexnp(str,sg,'tendencja',atr)}
mieć: imperf: subj,controller{np(str)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'imię',atr)}
mieć: imperf: subj,controller{np(str)} + controllee{np(nom)} + {preplexnp(na,acc,sg,'nazwisko',atr)}
mieć: imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
mieć: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
mieć: imperf: subj{np(str)} + {advp(misc)}
mieć: imperf: subj{np(str)} + {advp(misc)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieć: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepadjp(za,acc)} + {np(dat)}
mieć: imperf: subj{np(str)} + controller{np(str)} + controllee{prepadjp(za,acc)}
mieć: imperf: subj{np(str)} + controller{np(str)} + controllee{prepnp(za,acc)}
mieć: imperf: subj{np(str)} + controller{np(str); ncp(str,że)} + controllee{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,inst,_,'siebie',natr)}
mieć: imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,sg,'głowa',natr)}
mieć: imperf: subj{np(str)} + {np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
mieć: imperf: subj{np(str)} + {np(str)} + {prepnp(u,gen)}
mieć: imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
mieć: imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
mieć: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
mieć: imperf: subj{np(str)} + {prepnp(na,acc)}
mieć: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)} + {nonch}
mieć się: imperf: {prepadjp(ku,dat)}
mieć się: imperf: {prepnp(na,acc)}
mieć się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
mieć się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
mieć się: imperf: subj{np(str)} + {prepadjp(ku,dat)}
mieć się: imperf: subj{np(str)} + {preplexnp(na,loc,sg,'baczność',natr)}
mieć się: imperf: subj{np(str)} + {prepnp(ku,dat)}
mienić: imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
mienić: imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
mienić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
mienić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
mienić się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
mienić się: imperf: subj{np(str)} + {np(inst)}
mienić się: imperf: subj{np(str)} + {prepnp(od,gen)}
mierzyć: imperf: subj{np(str)} + {lexnp(str,pl,'siła',natr)} + {preplexnp(na,acc,pl,'zamiar',natr)}
mierzyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
mierzyć: imperf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
mierzyć: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
mierzyć: imperf: subj{np(str)} + {np(str)}
mierzyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
mierzyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mierzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
mierzyć: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
mierzyć: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
mierzyć się: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
mieszać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
mieszać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
mieszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
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)} + {np(dat)} + {prepnp(z,inst)}
mieszać się: imperf: subj{np(str)} + {prepnp(do,gen)}
mieszać się: imperf: subj{np(str)} + {prepnp(w,acc)}
mieszkać: imperf: subj,controller{np(str)} + controllee{xp(mod)}
mieszkać: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
mieszkać: imperf: subj{np(str)} + {prepnp(z,inst)}
mieścić: imperf: subj{np(str)} + {np(str)}
mieścić się: imperf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: imperf: subj{ncp(str,int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: imperf: subj{ncp(str,żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: imperf: subj{ncp(str,że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
mieścić się: imperf: subj{np(str)} + {prepnp(w,loc)}
mieścić się: imperf: subj{np(str)} + {xp(locat)}
migać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
migać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
migać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
migać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
migać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
migać się: imperf: subj{np(str)} + {prepnp(od,gen)}
migać się: imperf: subj{np(str)} + {prepnp(z,inst)}
migotać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
migotać: imperf: subj{np(str)} + {np(inst)}
migotać: imperf: subj{np(str)} + {prepnp(od,gen)}
mijać: imperf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
mijać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
mijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
mijać się: imperf: subj{np(str)} + {prepnp(z,inst)}
milczeć: imperf: subj,controller{np(str)} + controllee{prepnp(jak,str)} + {prepnp(o,loc); prepncp(o,loc,ż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)}
milknąć: perf: subj{np(str)}
minąć: perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
minąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
minąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
minąć się: perf: subj{np(str)} + {prepnp(z,inst)}
miotać: imperf: {np(inst)} + {prepnp(po,loc)}
miotać: imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
miotać: imperf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
miotać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
miotać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
miotać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
miotać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(z,gen)} + {xp(adl)}
miotać: imperf: subj{np(str)} + obj{np(inst)} + {xp(abl)} + {xp(adl)}
miotać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
miotać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
miotać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
miotać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
miotać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
miotać się: imperf: subj{np(str)} + {prepnp(między,inst)}
miotać się: imperf: subj{np(str)} + {prepnp(w,loc)}
miotać się: imperf: subj{np(str)} + {prepnp(z,gen)}
miotać się: imperf: subj{np(str)} + {prepnp(z,inst)}
miotać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
miotać się: imperf: subj{np(str)} + {xp(locat)}
mknąć: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
mknąć: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
mnożyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
mnożyć się: imperf: subj{np(str)}
mobilizować: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
mobilizować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
mobilizować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
mobilizować się: imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
mobilizować się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
mobilizować się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
moczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
moczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
moczyć: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
moczyć się: imperf: subj{np(str)} + {prepnp(w,loc)}
modlić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {or}
modlić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {cp(żeby)}
modlić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,inst)} + {cp(żeby)}
modyfikować: imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)} + {np(inst)}
modyfikować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
modyfikować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
modyfikować się: imperf: subj{np(str)}
monitorować: imperf: subj{np(str)} + {cp(int)}
monitorować: imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
montować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
montować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
mordować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mordować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
mordować się: imperf: subj{np(str)} + {prepnp(z,inst)}
mościć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mościć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
mościć się: imperf: subj{np(str)} + {xp(locat)}
motywować: imperf: subj{np(str)} + {cp(że)}
motywować: imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
motywować: imperf: subj{np(str)} + {np(inst)} + {refl}
motywować: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
motywować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
motywować: imperf: subj{np(str)} + obj{np(str)} + {or}
motywować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
motywować: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
można: imperf: {infp(_)}
móc: imperf: subj,controller{E} + controllee{infp(_)}
móc: imperf: subj,controller{np(str)} + controllee{infp(_)}
móc: imperf: subj{np(str)} + {np(str)}
mruczeć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mruczeć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
mruczeć: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
mruczeć: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
mruczeć: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
mruczeć: imperf: subj{np(str)} + {prepnp(na,acc)}
mruczeć: imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
mruczeć: imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
mruczeć: imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
mrugać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
mrugać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
mrugnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
mrugnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
mruknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
mruknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
mruknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
mruknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
mruknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
mruknąć: perf: subj{np(str)} + {prepnp(na,acc)}
mruknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {cp(że)}
mruknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
mruknąć: perf: subj{np(str)} + {prepnp(za,inst)} + {or}
mścić: imperf: subj{np(str)} + obj{np(str)}
mścić się: imperf: subj{ncp(str,że)} + {prepnp(na,loc)}
mścić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
mścić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
musieć: imperf: subj,controller{E} + controllee{infp(_)}
musieć: imperf: subj,controller{np(str)} + controllee{infp(_)}
musieć: imperf: subj{np(str)} + {xp(adl)}
myć: imperf: subj{np(str)} + {np(inst)} + {refl}
myć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
mylić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
mylić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
mylić się: imperf: subj{np(str)} + {np(dat)} + {prepncp(z,inst,że)}
mylić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
mylić się: imperf: subj{np(str)} + {prepncp(w,loc,że)}
mylić się: imperf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)}
mylić się: imperf: subj{np(str)} + {prepnp(w,loc)}
myśleć: imperf: subj,controller{np(str)} + controllee{infp(_)}
myśleć: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{prepadjp(jako,str)}
myśleć: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{prepnp(jako,str)}
myśleć: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
myśleć: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,żeby)}
myśleć: imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); cp(żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
myśleć: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nabić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
nabić: perf: subj{np(str)} + obj{np(part)}
nabić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nabić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nabić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nabić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
nabić się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nabierać: imperf: subj{np(str)} + {np(inst)} + {np(part)}
nabierać: imperf: subj{np(str)} + {np(part)} + {prepnp(na,acc)}
nabierać: imperf: subj{np(str)} + {np(part)} + {prepnp(w,acc)}
nabierać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
nabierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabierać się: imperf: subj{np(str)} + {cp(że)}
nabierać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabijać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabijać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabijać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {refl}
nabijać: imperf: subj{np(str)} + obj{np(part)}
nabijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nabijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(do,gen,sg,'głowa',atr)}
nabijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nabijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nabijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
nabijać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nabijać się: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
nabijać się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
nabrać: perf: subj{np(str)} + {np(part)} + {prepnp(na,acc)}
nabrać: perf: subj{np(str)} + {np(part)} + {prepnp(w,acc)}
nabrać: perf: subj{np(str)} + obj{np(part)} + {np(inst)}
nabrać: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
nabrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
nabrać się: perf: subj{np(str)} + {cp(że)}
nabrać się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
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)}
nachodzić: imperf: subj{cp(żeby)} + {np(str)}
nachodzić: imperf: subj{cp(że)} + {np(str)}
nachodzić: imperf: subj{np(str)} + {np(inst)}
nachodzić: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nachodzić: imperf: subj{np(str)} + {prepnp(na,acc)}
nachodzić się: imperf: subj{np(str)} + {prepnp(po,loc)}
nachodzić się: imperf: subj{np(str)} + {prepnp(przy,loc)}
nachodzić się: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
nachodzić się: imperf: subj{np(str)} + {xp(adl)}
nachylać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
nachylać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
nachylać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
nachylać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
nachylać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(ku,dat)}
nachylać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
nachylić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
nachylić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
nachylić: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
nachylić się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
nachylić się: perf: subj{np(str)} + {np(dat)} + {prepnp(ku,dat)}
nachylić się: perf: subj{np(str)} + {np(dat)} + {prepnp(nad,inst)}
nacierać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nacierać: imperf: subj{np(str)} + {np(inst)} + {refl}
nacierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nacierać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
nacierać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nacierać: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
nacierać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
nacierać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
nacieszyć: perf: subj{np(str)} + {np(inst)} + {np(str)}
nacieszyć się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
nacieszyć się: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
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)}
nadążać: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nadążać: imperf: subj{np(str)} + {cp(żeby)}
nadążać: imperf: subj{np(str)} + {prepnp(za,inst)}
nadążać: imperf: subj{np(str)} + {prepnp(z,inst)}
nadążyć: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nadążyć: imperf: subj{np(str)} + {cp(żeby)}
nadążyć: imperf: subj{np(str)} + {prepnp(za,inst)}
nadążyć: imperf: subj{np(str)} + {prepnp(z,inst)}
nadchodzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
nadejść: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
nadepnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
nadepnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nadesłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
nadesłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
nadrabiać: imperf: subj{np(str)} + {np(part)}
nadrabiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
nadrobić: perf: subj{np(str)} + {np(part)}
nadrobić: perf: subj{np(str)} + obj{np(part)} + {np(dat)}
nadrobić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
nadsyłać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
nadsyłać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
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)} + {np(dat)} + {np(inst)} + {refl}
nagrać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
nagrać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {refl}
nagrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nagrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
nagrać się: perf: subj{np(str)} + {np(gen)}
nagrać się: perf: subj{np(str)} + {prepnp(na,loc)}
nagrać się: perf: subj{np(str)} + {xp(locat)}
nakarmić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
nakarmić się: perf: subj{np(str)} + {np(inst)}
nakazać: perf: subj{np(str)} + {np(dat)} + {or}
nakazać: perf: subj{np(str)} + obj,controllee{cp(żeby); infp(_)} + controller{np(dat)}
nakazać: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
nakazać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
nakazywać: imperf: subj{np(str)} + {np(dat)} + {or}
nakazywać: imperf: subj{np(str)} + obj,controllee{cp(żeby); infp(_)} + controller{np(dat)}
nakazywać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
nakazywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nakłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
nakłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
nakłonić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
nakłonić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
nakręcić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
nakręcić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nakręcić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nakręcić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nakręcić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nakręcić: perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
nakręcić się: perf: subj{np(str)} + {np(inst)}
nalać: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nalać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nalać się: perf: subj{np(part)} + {np(dat)} + {xp(adl)} + {xp(perl)}
nalegać: imperf: subj{np(str)} + {or}
nalegać: imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
nalegać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nalegać: imperf: subj{np(str)} + {prepnp(o,acc)}
nalewać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
nalewać się: imperf: subj{np(part)} + {np(dat)} + {xp(adl)} + {xp(perl)}
należeć: imperf: {infp(_)}
należeć: imperf: subj{cp(żeby)} + {prepnp(do,gen)}
należeć: imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(do,gen)}
należeć się: imperf: subj{cp(żeby)} + {np(dat)}
należeć się: imperf: subj{np(str)} + {np(dat)}
należeć się: perf: subj{np(str)} + {xp(locat)}
naliczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
naliczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
naliczyć się: perf: subj{np(str)} + {np(gen)}
namawiać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
namawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); prepncp(na,acc,żeby)}
namawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
namawiać: imperf: subj{np(str)} + {or}
namawiać się: imperf: subj{np(str)} + {prepnp(z,inst)}
namówić: perf: subj{np(str)} + {np(str)} + {prepncp(na,acc,żeby)}
namówić: perf: subj{np(str)} + {np(str)} + {prepnp(przeciw,dat)}
namówić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
namówić: perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
namówić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepnp(na,acc)}
namówić się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
namyślać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
namyślać się: imperf: subj{np(str)} + {cp(int)}
namyślać się: imperf: subj{np(str)} + {or}
namyślać się: imperf: subj{np(str)} + {prepncp(nad,inst,int)}
namyślać się: imperf: subj{np(str)} + {prepnp(nad,inst)}
nanieść: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
nanieść: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nanieść: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
nanieść: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
nanieść się: perf: {np(part)} + {xp(abl)} + {xp(adl)}
nanieść się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nanosić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
nanosić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
nanosić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
nanosić: _: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
nanosić się: perf: subj{np(str)} + {np(gen)}
nanosić się: _: {np(part)} + {xp(abl)} + {xp(adl)}
nanosić się: _: subj{np(str)} + {xp(abl)} + {xp(adl)}
napaść: perf: subj{cp(żeby)} + {np(str)}
napaść: perf: subj{nonch} + {np(str)} + {cp(żeby)}
napaść: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
napaść: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napaść: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
napaść: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
napaść się: perf: subj{np(str)} + {np(inst)}
napawać: imperf: subj{cp(gdy)} + {np(inst)} + {np(str)}
napawać: imperf: subj{cp(int)} + {np(inst)} + {np(str)}
napawać: imperf: subj{cp(jak)} + {np(inst)} + {np(str)}
napawać: imperf: subj{cp(jeśli)} + {np(inst)} + {np(str)}
napawać: imperf: subj{cp(kiedy)} + {np(inst)} + {np(str)}
napawać: imperf: subj{cp(że)} + {np(inst)} + {np(str)}
napawać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {np(str)}
napawać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napawać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
napiąć: perf: subj{np(str)} + obj{np(str)}
napiąć się: perf: subj{np(str)} + {np(dat)}
napić się: perf: subj{np(str)} + {np(gen)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
napić się: perf: subj{np(str)} + {np(inst)}
napisać: perf: subj{np(str)} + {np(dat)} + {cp(int)}
napisać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
napisać: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
napisać: perf: subj{np(str)} + {np(dat)} + {or}
napisać: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
napisać: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {or}
napisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
napisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
napisać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
napisać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
napisać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int); cp(że); cp(żeby)}
napisać: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
napisać: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
napisać: perf: subj{np(str)} + {prepnp(o,loc)} + {cp(int)}
napisać: perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
napłynąć: perf: subj{np(str)} + {np(dat)} + {np(inst)}
napłynąć: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
napłynąć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
napłynąć: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
napłynąć: perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
napływać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
napływać: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
napływać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
napływać: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
napływać: imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
napływać się: perf: subj{np(str)}
napoić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napoić się: perf: subj{np(str)} + {np(inst)}
napotkać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
napotkać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
napotkać: perf: subj{np(str)} + {prepnp(na,acc)}
napotykać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
napotykać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
napotykać: imperf: subj{np(str)} + {prepnp(na,acc)}
naprawiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
naprawiać się: imperf: subj{np(str)}
naprawić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
naprawić się: perf: subj{np(str)}
naradzać się: imperf: subj{np(str)} + {prepnp(co do,gen)} + {prepnp(z,inst)}
naradzać się: imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(z,inst)}
naradzać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
naradzać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
naradzać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
naradzać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
naradzać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(nad,inst,int)}
narastać: imperf: {np(gen)} + {xp(locat)}
narastać: imperf: subj{np(str)} + {np(dat)}
narastać: imperf: subj{np(str)} + {prepnp(w,loc)}
narastać: imperf: subj{np(str)} + {xp(dur)}
narastać: imperf: subj{np(str)} + {xp(locat)}
narazić: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)} + {refl}
narazić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)}
narazić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,acc)}
narazić: perf: subj{np(str)} + {prepnp(dla,gen)} + {refl}
narazić się: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
narażać: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)} + {refl}
narażać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(na,acc); prepncp(na,acc,że)}
narażać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
narażać: imperf: subj{np(str)} + {prepnp(dla,gen)} + {refl}
narażać się: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)}
narosnąć: perf: {np(gen)} + {xp(locat)}
narosnąć: perf: subj{np(str)} + {np(dat)}
narosnąć: perf: subj{np(str)} + {prepnp(w,loc)}
narosnąć: perf: subj{np(str)} + {xp(locat)}
narysować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
narysować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
narysować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
narysować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
narzucać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
narzucać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
narzucać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
narzucać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
narzucać: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
narzucać się: imperf: subj{cp(że)} + {np(dat)}
narzucać się: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
narzucać się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
narzucać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
narzucać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
narzucać się: perf: subj{np(str)} + {np(gen)}
narzucać się: perf: subj{np(str)} + {np(inst)}
narzucić: perf: subj{np(str); ncp(str,że)} + {np(dat)}
narzucić: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
narzucić: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
narzucić: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(do,gen)}
narzucić: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(na,acc)}
narzucić się: perf: subj{cp(że)} + {np(dat)}
narzucić się: perf: subj{np(str)} + {np(dat)} + {np(inst)}
narzucić się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
nasilać: imperf: subj{np(str)} + obj{np(str)}
nasilać się: imperf: subj{np(str)}
nasilić: perf: subj{np(str)} + obj{np(str)}
nasilić się: perf: subj{np(str)}
nasłuchiwać: imperf: subj{np(str)} + {cp(int)}
nasłuchiwać: imperf: subj{np(str)} + {cp(jak)}
nasłuchiwać: imperf: subj{np(str)} + {np(gen)}
nastać: perf: subj{np(str)} + {xp(locat)}
nastać się: perf: subj{np(str)} + {xp(locat)}
nastawać: imperf: subj{np(str)} + {or}
nastawać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
nastawać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
nastawać: imperf: subj{np(str)} + {xp(locat)}
nastawiać: imperf: subj{np(str)} + controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
nastawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nastawiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nastawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nastawiać: perf: subj{np(str)} + {np(gen)} + {xp(locat)}
nastawiać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
nastawiać się: imperf: subj{np(str)} + {prepnp(na,acc)}
nastąpić: perf: subj,controller{np(str)} + controllee{xp(mod)}
nastąpić: perf: subj{ncp(str,że)}
nastąpić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nastąpić: perf: subj{np(str)} + {prepnp(po,loc)}
nastąpić: perf: subj{np(str)} + {xp(temp)}
następować: imperf: subj,controller{np(str)} + controllee{xp(mod)}
następować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
następować: imperf: subj{np(str)} + {prepnp(po,loc)}
następować: imperf: subj{np(str)} + {xp(temp)}
nastrajać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastrajać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastrajać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nastrajać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastrajać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {advp(misc)}
nastrajać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
nastrajać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastroić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastroić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nastroić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nastroić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)} + {advp(misc)}
nastroić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {advp(misc)}
nastroić się: perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
nastroić się: perf: subj{np(str)} + {prepnp(na,acc)} + {advp(misc)}
nasuwać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
nasuwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: perf: subj{cp(że)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
nasuwać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
naśladować: imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
naśladować: imperf: subj{np(str)} + obj{np(str)}
natchnąć: perf: {np(str)} + {cp(żeby)}
natchnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
natchnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
natknąć się: perf: subj{np(str)} + {prepncp(na,acc,int)}
natknąć się: perf: subj{np(str)} + {prepncp(na,acc,że)}
natknąć się: perf: subj{np(str)} + {prepnp(na,acc)}
natrafiać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrafić: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
natrzeć: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'ucho',natr)}
natrzeć: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
natrzeć: perf: subj{np(str)} + {np(inst)} + {refl}
natrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
natrzeć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
natrzeć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
natrzeć: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
natrzeć: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
natrzeć: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
nauczać: imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
nauczać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {np(inst)}
nauczać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
nauczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nauczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {np(inst)}
nauczyć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
nauczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
nauczyć się: perf: subj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {prepnp(od,gen); prepnp(z,gen)}
nauczyć się: perf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
nauczyć się: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
nawiązać: perf: subj{np(str)} + {np(gen)}
nawiązać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
nawiązać: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
nawiązać: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
nawiązać się: perf: subj{np(str)} + {prepnp(między,inst)}
nawiedzać: imperf: subj{np(str)} + obj{np(str)}
nawiedzić: perf: subj{np(str)} + obj{np(str)}
nawozić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
nawozić: perf: subj{np(str)} + {np(gen)}
nawozić się: perf: subj{np(str)} + {np(gen)}
nazwać: perf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
nazwać: perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
nazwać: perf: subj,controller{np(str)} + controllee{np(nom)} + {refl}
nazwać: perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
nazwać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
nazwać: perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,loc)}
nazwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nazwać: perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
nazywać: imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
nazywać: imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
nazywać: imperf: subj,controller{np(str)} + controllee{np(nom)} + {refl}
nazywać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
nazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
nazywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
nazywać się: imperf: subj,controller{np(str)} + controllee{np(inst)}
nazywać się: imperf: subj,controller{np(str)} + controllee{np(nom)}
nazywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
negocjować: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + obj{cp(int)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
negocjować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
negocjować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
negocjować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
negować: imperf: subj{np(str)} + obj{cp(int)}
negować: imperf: subj{np(str)} + obj{cp(że)}
negować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
nękać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,że)}
niecierpliwić: imperf: subj{cp(że)} + {np(str)}
niecierpliwić: imperf: subj{np(str); ncp(str,że)} + {np(str)}
niecierpliwić się: imperf: subj{np(str)} + {cp(int)}
niecierpliwić się: imperf: subj{np(str)} + {cp(że)}
niecierpliwić się: imperf: subj{np(str)} + {cp(żeby)}
niecierpliwić się: imperf: subj{np(str)} + {np(inst)}
niecierpliwić się: imperf: subj{np(str)} + {or}
nienawidzić: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
nienawidzić: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
nienawidzić: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
niepokoić: imperf: subj{cp(gdy)} + {np(str)}
niepokoić: imperf: subj{cp(jak)} + {np(str)}
niepokoić: imperf: subj{cp(jeśli)} + {np(str)}
niepokoić: imperf: subj{cp(kiedy)} + {np(str)}
niepokoić: imperf: subj{cp(że)} + {np(str)}
niepokoić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
niepokoić: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
niepokoić się: imperf: subj{np(str)} + {cp(int)}
niepokoić się: imperf: subj{np(str)} + {cp(że)}
niepokoić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
niepokoić się: imperf: subj{np(str)} + {or}
niepokoić się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
nieść: imperf: {np(inst)} + {xp(abl)}
nieść: imperf: {np(str)} + {xp(abl)} + {xp(adl)}
nieść: imperf: {np(str)} + {xp(perl)}
nieść: imperf: subj{np(str)} + {cp(że)}
nieść: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
nieść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
nieść: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
nieść: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
nieść: imperf: subj{np(str)} + {xp(locat)} + {or}
nieść się: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
nieść się: imperf: subj{np(str)} + {or}
nieść się: imperf: subj{np(str)} + {prepnp(z,inst)}
nieść się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
nieść się: imperf: subj{np(str)} + {xp(perl)}
niknąć: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
niknąć: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
niknąć: imperf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',natr)}
niknąć: imperf: subj{np(str)} + {prepnp(przy,loc)}
niszczyć: imperf: subj{np(str)} + {np(inst)} + {refl}
niszczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
niszczyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
nocować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
nocować: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)} + {preplexnp(na,acc,sg,'walet',natr)}
nominować: _: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
nominować: _: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
nominować: _: subj{np(str)} + {prepnp(do,gen)} + {refl}
nominować: _: subj{np(str)} + {prepnp(na,acc)} + {refl}
nosić: imperf: {np(str)} + {xp(abl)} + {xp(adl)}
nosić: imperf: {np(str)} + {xp(perl)}
nosić: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
nosić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(locat)}
nosić się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
nosić się: imperf: subj{np(str)} + {prepnp(z,inst)}
notować: imperf: subj{np(str)} + {cp(żeby2)}
notować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
notować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
notować: imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
notować: imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
notować: imperf: subj{np(str)} + {prepnp(na,loc)} + {or}
notować: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(int)}
notować: imperf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
notować: imperf: subj{np(str)} + {prepnp(w,loc)} + {or}
nowelizować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
nudzić: imperf: {np(str)}
nudzić: imperf: subj{cp(gdy)} + {np(str)}
nudzić: imperf: subj{cp(jak)} + {np(str)}
nudzić: imperf: subj{cp(kiedy)} + {np(str)}
nudzić: imperf: subj{cp(że)} + {np(str)}
nudzić: imperf: subj{np(str)} + {cp(że)}
nudzić: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
nudzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
nudzić: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
nudzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
nudzić: imperf: subj{np(str)} + {or}
nudzić się: imperf: subj,controllee{infp(imperf)} + controller{np(dat)}
nudzić się: imperf: subj{cp(że)} + {np(dat)}
nudzić się: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
nudzić się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
nurtować: imperf: subj{cp(int)} + {np(str)}
nurtować: imperf: subj{cp(żeby)} + {np(str)}
nurtować: imperf: subj{cp(że)} + {np(str)}
nurtować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
nurtować: imperf: subj{np(str)} + {prepnp(w,loc)}
obawiać się: imperf: subj{np(str)} + {cp(int)}
obawiać się: imperf: subj{np(str)} + {cp(żeby)}
obawiać się: imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); infp(_)}
obawiać się: imperf: subj{np(str)} + {prepnp(o,acc); cp(że); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
obchodzić: imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(str)}
obchodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
obchodzić: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
obchodzić się: imperf: {prepnp(bez,gen)}
obchodzić się: imperf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
obchodzić się: imperf: subj{np(str)} + {np(inst)}
obchodzić się: imperf: subj{np(str)} + {prepnp(bez,gen)}
obciąć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
obciąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
obciąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obciąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obciąć się: perf: subj,controller{np(str)} + controllee{xp(mod)}
obciąć się: perf: subj{np(str)} + {prepnp(na,loc)}
obciąć się: perf: subj{np(str)} + {prepnp(z,gen)}
obcinać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(inst)}
obcinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
obcinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obcinać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obcinać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
obcinać się: imperf: subj{np(str)} + {prepnp(na,loc)}
obcinać się: imperf: subj{np(str)} + {prepnp(z,gen)}
obcować: imperf: subj{np(str)} + {prepnp(z,inst)}
obdarować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarowywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obdarzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obejmować: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
obejmować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
obejmować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
obejmować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
obejmować się: imperf: subj{np(str)} + {prepnp(z,inst)}
obejrzeć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w roli)}
obejrzeć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
obejrzeć: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
obejrzeć: perf: subj{np(str)} + {xp(locat)} + {refl}
obejrzeć się: perf: subj{np(str)} + {prepnp(na,acc)}
obejrzeć się: perf: subj{np(str)} + {prepnp(za,inst)}
obejść: perf: subj{cp(że)} + {np(str)}
obejść: perf: subj{np(str)} + {np(str)} + {xp(abl)}
obejść się: perf: {prepnp(bez,gen)}
obejść się: perf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
obejść się: perf: subj{np(str)} + {np(inst)}
obejść się: perf: subj{np(str)} + {prepnp(bez,gen)}
oberwać: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {prepnp(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)}
obfitować: imperf: subj{np(str)} + {np(inst)}
obfitować: imperf: subj{np(str)} + {prepnp(w,acc)}
obiecać: perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
obiecać: perf: subj{np(str)} + {np(dat)} + {or}
obiecać: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
obiecywać: imperf: subj,controller{np(str)} + obj,controllee{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)}
obiecywać: imperf: subj{np(str)} + obj{or} + {np(dat)}
objaśniać: imperf: subj{np(str)} + {np(dat)} + {or}
objaśniać: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
objaśniać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
objaśniać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {or}
objaśniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
objaśnić: perf: subj{np(str)} + {np(dat)} + {or}
objaśnić: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
objaśnić: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
objaśnić: perf: subj{np(str)} + obj{np(str)} + {comprepnp(co do)}
objaśnić: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
objaśnić: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
objaśnić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
objaśnić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
objaśnić: perf: subj{np(str)} + obj{np(str)} + {or}
objaśnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
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)}
oblać: perf: subj{np(str)} + {np(inst)} + {refl}
oblać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
oblać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oblać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oblać się: perf: subj{np(str)} + {np(inst)}
oblewać: imperf: subj{np(str)} + {np(inst)} + {refl}
oblewać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
oblewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oblewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oblewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
oblewać się: imperf: subj{np(str)} + {np(inst)}
obliczać: imperf: subj{np(str)} + {cp(int)}
obliczać: imperf: subj{np(str)} + {cp(że)}
obliczać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obliczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obmyślać: imperf: subj{np(str)} + {cp(int)}
obmyślać: imperf: subj{np(str)} + obj{np(str)}
obnażać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
obnażać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
obnażyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
obnażyć się: perf: subj{np(str)} + {prepnp(przed,inst)}
obowiązywać: imperf: subj{np(str)} + {np(str)}
obowiązywać: imperf: subj{np(str)} + {xp(dur)}
obracać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
obracać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
obracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
obracać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
obracać się: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
obracać się: imperf: subj{np(str)} + {prepadjp(na,acc)}
obracać się: imperf: subj{np(str)} + {prepnp(na,acc)}
obracać się: imperf: subj{np(str)} + {prepnp(na,loc)}
obracać się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
obracać się: imperf: subj{np(str)} + {prepnp(wokół,gen)}
obrać: perf: subj{np(str)} + {np(inst)} + {refl}
obrać: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
obrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
obrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
obrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
obradować: imperf: subj{np(str)} + {prepnp(nad,inst); comprepnp(w sprawie); prepncp(nad,inst,int)}
obradować: imperf: subj{np(str)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int)}
obrażać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obrażać się: imperf: subj{np(str)} + {or}
obrażać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
obrażać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
obrażać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepncp(o,acc,że)}
obrażać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepncp(za,acc,że)}
obrażać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc)}
obrażać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
obró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)}
obrzucać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obrzucić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obsadzać: perf: subj{np(str)} + {np(inst)} + {refl}
obsadzać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsadzać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
obsadzać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obsadzać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obsadzać: perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
obsadzać: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
obsadzić: perf: subj{np(str)} + {np(inst)} + {refl}
obsadzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsadzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {advp(misc)}
obsadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
obsadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
obsadzić: perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
obsadzić: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
obserwować: imperf: subj{np(str)} + {cp(int)}
obserwować: imperf: subj{np(str)} + {cp(jak)}
obserwować: imperf: subj{np(str)} + {cp(że)}
obserwować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
obsługiwać: imperf: subj{np(str)} + obj{np(str)}
obsługiwać: imperf: subj{np(str)} + {refl}
obsłużyć: perf: subj{np(str)} + obj{np(str)}
obsłużyć: perf: subj{np(str)} + {refl}
obstawać: imperf: subj{np(str)} + {cp(że)}
obstawać: imperf: subj{np(str)} + {cp(żeby)}
obstawać: imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)}
obstawać: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)}
obstawiać: imperf: subj{np(str)} + {cp(int)}
obstawiać: imperf: subj{np(str)} + {cp(że)}
obstawiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
obstawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
obstawiać: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
obstawiać się: imperf: subj{np(str)} + {np(inst)}
obstawić: perf: subj{np(str)} + {cp(int)}
obstawić: perf: subj{np(str)} + {cp(że)}
obstawić: perf: subj{np(str)} + {np(inst)} + {refl}
obstawić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
obstawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
obstawić: perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,że)}
obsypać: perf: subj{np(str)} + {np(inst)} + {refl}
obsypać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsypać się: perf: subj{np(str)} + {xp(abl)}
obsypać się: perf: subj{np(str)} + {xp(adl)}
obsypywać: imperf: subj{np(str)} + {np(inst)} + {refl}
obsypywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
obsypywać się: imperf: subj{np(str)} + {xp(abl)}
obsypywać się: imperf: subj{np(str)} + {xp(adl)}
obudzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
obudzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
obudzić się: perf: subj,controller{np(str)} + controllee{adjp(inst)}
obudzić się: perf: subj,controller{np(str)} + controllee{np(inst)}
obudzić się: perf: subj{np(str)} + {prepnp(w,loc)}
obudzić się: perf: subj{np(str)} + {prepnp(z,gen)}
oburzać: imperf: subj{cp(gdy)} + {np(str)}
oburzać: imperf: subj{cp(jak)} + {np(str)}
oburzać: imperf: subj{cp(jeśli)} + {np(str)}
oburzać: imperf: subj{cp(kiedy)} + {np(str)}
oburzać: imperf: subj{cp(że)} + {np(str)}
oburzać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {np(str)}
oburzać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
oburzać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
oburzać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
oburzać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {or}
oburzać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
oburzać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
oburzyć: perf: subj{cp(gdy)} + {np(str)}
oburzyć: perf: subj{cp(jak)} + {np(str)}
oburzyć: perf: subj{cp(jeśli)} + {np(str)}
oburzyć: perf: subj{cp(kiedy)} + {np(str)}
oburzyć: perf: subj{cp(że)} + {np(str)}
oburzyć: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {np(str)}
oburzyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
oburzyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
oburzyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
oburzyć się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {or}
oburzyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
oburzyć się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)}
obuwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
obuwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
obuwać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
obyć się: perf: subj{np(str)} + {np(inst)}
obyć się: perf: subj{np(str)} + {prepnp(bez,gen); prepncp(bez,gen,że); prepncp(bez,gen,żeby)}
obyć się: perf: subj{np(str)} + {prepnp(z,inst)}
obywać się: imperf: subj{np(str)} + {np(inst)}
obywać się: imperf: subj{np(str)} + {prepnp(bez,gen); prepncp(bez,gen,że); prepncp(bez,gen,żeby)}
obywać się: imperf: subj{np(str)} + {prepnp(z,inst)}
ocalać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
ocalać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
ocalać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ocalać: imperf: subj{np(str)} + {prepnp(od,gen)} + {refl}
ocalać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
ocalać: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
ocalić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
ocalić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(przed,inst)}
ocalić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ocalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ocalić: perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
ocalić: perf: subj{np(str)} + {prepnp(przed,inst)} + {refl}
ocalić: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
oceniać: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
oceniać: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
oceniać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
oceniać: imperf: subj{np(str)} + {cp(int)}
oceniać: imperf: subj{np(str)} + {cp(że)}
oceniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
oceniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oceniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
oceniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oceniać: imperf: subj{np(str)} + {or} + {refl}
oceniać: imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
ocenić: perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
ocenić: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
ocenić: perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
ocenić: perf: subj{np(str)} + {cp(int)}
ocenić: perf: subj{np(str)} + {cp(że)}
ocenić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
ocenić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
ocenić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ocenić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ocenić: perf: subj{np(str)} + {or} + {refl}
ocenić: perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
ochłonąć: imperf: subj{np(str)} + {prepnp(z,gen)}
ochraniać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochraniać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
ochraniać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {refl}
ochraniać: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {refl}
ochronić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
ochronić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
ochronić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {refl}
ochronić: perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst); prepncp(przed,inst,że); prepncp(przed,inst,żeby)} + {refl}
ochrzcić: perf: subj{np(str)} + {np(inst)} + {refl}
ochrzcić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ochrzcić się: perf: subj{np(str)}
ociągać się: imperf: subj{np(str)} + {prepnp(z,inst)}
ocierać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
ocierać: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
ocierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
ocierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
ocierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
ocierać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
ocierać się: imperf: subj{np(str)} + {xp(locat)}
ocknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ocknąć się: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
odbiegać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odbiegać: imperf: subj{np(str)} + {np(str)}
odbiegać: imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
odbiegać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
odbierać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odbierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odbierać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odbijać: imperf: {np(dat)}
odbijać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbijać: imperf: subj{np(str)} + {np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
odbijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odbijać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,pl,'ręka',ratr)}
odbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
odbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
odbijać: imperf: subj{np(str)} + {xp(abl)}
odbijać: imperf: subj{np(str)} + {xp(adl)}
odbijać się: imperf: {np(dat)} + {np(inst)}
odbijać się: imperf: {np(dat)} + {prepnp(po,loc)}
odbijać się: imperf: subj{np(str)} + controller{prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)} + controllee{xp(mod)}
odbijać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odbijać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
odbijać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odbijać się: imperf: subj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
odbijać się: imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(inst,sg,'echo',atr)}
odbijać się: imperf: subj{np(str)} + {xp(locat)} + {lexnp(inst,sg,'echo',atr)}
odbudować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odbudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odbudować się: perf: subj{np(str)} + {prepnp(z,gen)}
odbyć: perf: subj{np(str)} + obj{np(str)}
odbyć się: perf: subj,controller{np(str)} + controllee{xp(mod)}
odbyć się: perf: subj{np(str)} + {xp(locat)}
odbyć się: perf: subj{np(str)} + {xp(temp)}
odbywać: imperf: subj{np(str)} + obj{np(str)}
odbywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
odbywać się: imperf: subj{np(str)} + {xp(locat)}
odbywać się: imperf: subj{np(str)} + {xp(temp)}
odciąć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odciąć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odciąć się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odciąć się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odciąć się: imperf: subj{np(str)} + {np(dat)} + {or}
odciąć się: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odcinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odcinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odcinać się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odcinać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
odcinać się: imperf: subj{np(str)} + {np(dat)} + {or}
odcinać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odczekać: perf: subj{np(str)} + {np(str)} + {cp(aż)}
odczuć: perf: subj{np(str)} + {cp(żeby2)}
odczuć: perf: subj{np(str)} + {np(inst)} + {cp(int)}
odczuć: perf: subj{np(str)} + {np(inst)} + {cp(że)}
odczuć: perf: subj{np(str)} + {np(str)} + {xp(locat)}
odczuć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
odczuwać: imperf: subj{np(str)} + {cp(int)}
odczuwać: imperf: subj{np(str)} + {cp(jak)}
odczuwać: imperf: subj{np(str)} + {cp(jakoby)}
odczuwać: imperf: subj{np(str)} + {cp(że)}
odczuwać: imperf: subj{np(str)} + {cp(żeby2)}
odczuwać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczuwać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2)}
odczytać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczytać: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odczytać: perf: subj{np(str)} + {or}
odczytywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odczytywać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
odczytywać: imperf: subj{np(str)} + {or}
oddać: perf: subj{np(str)} + {np(dat)} + {adjp(inst)} + {prepadjp(za,acc)}
oddać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
oddać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
oddać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
oddać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
oddać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oddać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
oddać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
oddać się: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'dyspozycja',atr)}
oddać się: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'niewola',atr)}
oddać się: perf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddać się: perf: subj{np(str)} + {prepnp(w,acc)}
oddalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oddalać się: imperf: subj{np(str)} + {prepnp(od,gen)}
oddalać się: imperf: subj{np(str)} + {xp(abl)}
oddalać się: imperf: subj{np(str)} + {xp(adl)}
oddalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
oddalić się: perf: subj{np(str)} + {prepnp(od,gen)}
oddalić się: perf: subj{np(str)} + {xp(abl)}
oddalić się: perf: subj{np(str)} + {xp(adl)}
oddawać: imperf: subj{np(str)} + {np(dat)} + {adjp(inst)} + {prepadjp(za,acc)}
oddawać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oddawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
oddawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
oddawać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oddawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oddawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
oddawać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
oddawać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'dyspozycja',atr)}
oddawać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'niewola',atr)}
oddawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
oddawać się: imperf: subj{np(str)} + {prepnp(w,acc)}
oddychać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(inst); prepnp(przez,acc)}
oddychać: imperf: subj{np(str)} + {np(inst); prepnp(przez,acc)}
oddziaływać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
oddziaływać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
odebrać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odebrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odebrać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odechcieć się: perf: controller{np(dat)} + controllee{infp(_)}
odechcieć się: perf: {np(dat)} + {np(gen)}
odejmować: imperf: {np(dat)} + {np(str)}
odejmować: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'rok',natr)}
odejmować: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
odejmować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odejmować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odepchnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odepchnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odeprzeć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
odeprzeć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odeprzeć: perf: subj{np(str)} + {np(dat)} + {or}
odeprzeć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
oderwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
oderwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
oderwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
oderwać się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
oderwać się: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {lexnp(inst,_,'myśl',natr)}
odetchnąć: perf: subj{np(str)} + {np(inst)}
odetchnąć: perf: subj{np(str)} + {prepnp(po,loc)}
odetchnąć: perf: subj{np(str)} + {prepnp(przed,inst)}
odezwać się: perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)} + {or}
odezwać się: perf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
odezwać się: perf: subj{np(str)} + {cp(że)}
odezwać się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odezwać się: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
odezwać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
odezwać się: perf: subj{np(str)} + {prepnp(o,loc)} + {or}
odezwać się: perf: subj{np(str)} + {prepnp(przeciw,dat)}
odezwać się: perf: subj{np(str)} + {prepnp(w,loc)}
odgarnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odgarniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odjąć: perf: {np(dat)} + {np(str)}
odjąć: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,pl,'rok',natr)}
odjąć: perf: subj{np(str)} + {np(dat)} + {np(gen)}
odjąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odjąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odkładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
odkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
odkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odkładać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
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)}
odkupić: perf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
odkupić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odkupić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odkupić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
odkupić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); xp(abl)} + {prepnp(za,acc)}
odkupić się: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odlatywać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odlatywać: imperf: subj{np(str)} + {prepnp(na,loc)}
odlatywać: imperf: subj{np(str)} + {prepnp(od,gen)}
odlatywać: imperf: subj{np(str)} + {prepnp(z,gen)}
odlecieć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odlecieć: perf: subj{np(str)} + {prepnp(na,loc)}
odlecieć: perf: subj{np(str)} + {prepnp(od,gen)}
odlecieć: perf: subj{np(str)} + {prepnp(z,gen)}
odliczać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(od,gen)}
odliczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odliczać: imperf: subj{np(str)} + {prepnp(do,gen)}
odliczać się: imperf: subj{np(str)} + {xp(locat)}
odliczyć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(od,gen)}
odliczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odliczyć: perf: subj{np(str)} + {prepnp(do,gen)}
odliczyć się: perf: subj{np(str)} + {xp(locat)}
odłączyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odłączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odłączyć się: perf: subj{np(str)} + {prepnp(od,gen)}
odłożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
odłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
odłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
odłożyć się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
odmawiać: imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że)}
odmawiać: imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
odmawiać: imperf: subj{np(str)} + obj{np(str)}
odmieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
odmieniać się: imperf: subj{np(str)} + {prepnp(przez,acc)}
odmówić: perf: subj{np(str)} + obj{np(gen); ncp(gen,że)} + {np(dat)}
odmówić: perf: subj{np(str)} + obj{np(str)}
odnajdywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen); xp(locat)}
odnajdywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
odnajdywać się: imperf: subj{np(str)} + {prepnp(u,gen)}
odnajdywać się: imperf: subj{np(str)} + {prepnp(w,loc)}
odnajdywać się: imperf: subj{np(str)} + {xp(locat)}
odnaleźć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen); xp(locat)}
odnaleźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); prepnp(w,loc); prepncp(w,loc,że)}
odnaleźć się: perf: subj{np(str)} + {prepnp(u,gen)}
odnaleźć się: perf: subj{np(str)} + {prepnp(w,loc)}
odnaleźć się: perf: subj{np(str)} + {xp(locat)}
odnawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odnawiać się: imperf: subj{np(str)} + {np(dat)}
odnawiać się: imperf: subj{np(str)} + {prepnp(u,gen)}
odnieść: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odnieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odnieść: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odnieść się: perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
odnosić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odnosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odnosić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odnosić się: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
odnowić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odnowić się: perf: subj{np(str)} + {np(dat)}
odnowić się: perf: subj{np(str)} + {prepnp(u,gen)}
odpalać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpalać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpalać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpalać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odpalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odpalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odpalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpalać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odpalać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odpalać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odpalić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpalić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpalić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpalić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
odpalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odpalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odpalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpalić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
odpalić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odpalić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odpędzać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odpędzać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odpędzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odpędzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odpiąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odpiąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
odpiąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odpiąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
odpiąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odpiąć: perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
odpiąć: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
odpiąć się: perf: subj{np(str)} + {np(dat)}
odpiąć się: perf: subj{np(str)} + {prepnp(od,gen)}
odpiąć się: perf: subj{np(str)} + {prepnp(z,gen)}
odpierać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odpierać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odpierać: imperf: subj{np(str)} + {np(dat)} + {or}
odpierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
odpisać: perf: subj{np(str)} + {np(dat)} + {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(do,gen)}
odpłynąć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpłynąć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odpływać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odpływać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
odpływać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
odpocząć: perf: subj{np(str)} + {prepnp(od,gen)}
odpocząć: perf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
odpoczywać: imperf: subj{np(str)} + {preplexnp(w,loc,sg,'pokój',atr)}
odpoczywać: imperf: subj{np(str)} + {prepnp(od,gen)}
odpoczywać: imperf: subj{np(str)} + {prepnp(po,loc); prepnp(przed,inst)}
odpowiadać: imperf: subj,controllee{infp(_)} + controller{np(dat)}
odpowiadać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(na,acc)}
odpowiadać: imperf: subj{cp(że)} + {np(dat)}
odpowiadać: imperf: subj{np(str)} + {ncp(dat,żeby)}
odpowiadać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
odpowiadać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odpowiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpowiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpowiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpowiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpowiadać: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odpowiadać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odpowiadać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
odpowiadać: imperf: subj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
odpowiadać: imperf: subj{np(str)} + {prepnp(z,gen)}
odpowiedzieć: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(na,acc)}
odpowiedzieć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
odpowiedzieć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
odpowiedzieć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odpowiedzieć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odpowiedzieć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odpowiedzieć: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
odpowiedzieć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
odpowiedzieć: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odpowiedzieć: perf: subj{np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
odpowiedzieć: perf: subj{np(str)} + {prepnp(z,gen)}
odprawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odprawiać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
odprawiać się: imperf: subj{np(str)} + {xp(locat)}
odprawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(abl)} + {xp(adl)}
odprawić się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
odprawić się: perf: subj{np(str)} + {xp(locat)}
odprowadzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); xp(adl)} + {xp(abl)}
odprowadzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); xp(adl)} + {xp(abl)}
odpuszczać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
odpuszczać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odpuszczać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
odpuścić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
odpuścić: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odpuścić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
odpychać: imperf: subj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)} + {np(str)}
odpychać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {preplexnp(od,gen,_,'siebie',natr)}
odpychać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odpychać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {xp(adl)}
odrabiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odradzać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
odradzać: imperf: subj{np(str)} + {np(dat)} + {ncp(str,żeby)}
odradzać: imperf: subj{np(str)} + {np(dat)} + {or}
odradzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odradzać się: imperf: subj{np(str)} + {prepnp(w,loc)}
odrobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
odróżniać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen)}
odróżniać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
odróżniać: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
odróżniać: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
odróżniać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(od,gen)}
odróżnić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen)}
odróżnić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
odróżnić: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
odróżnić: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
odróżnić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(od,gen)}
odrywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
odrywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
odrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)}
odrywać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odrywać się: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {lexnp(inst,_,'myśl',natr)}
odrzec: perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(na,acc)}
odrzec: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
odrzec: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(żeby)}
odrzec: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
odrzec się: perf: subj{np(str)} + {np(gen)}
odrzec się: perf: subj{np(str)} + {prepnp(od,gen)}
odrzucać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {prepnp(od,gen)}
odrzucać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(od,gen)}
odrzucać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odrzucać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odrzucić: perf: {np(str)} + {prepnp(od,gen)}
odrzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odrzucić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
odrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
odrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odrzucić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odsłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
odsłaniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odsłaniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
odsłaniać się: imperf: subj{np(str)} + {np(dat)}
odsłaniać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
odsłaniać się: imperf: subj{np(str)} + {prepnp(wobec,gen)}
odsłonić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odsłonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
odsłonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
odsłonić się: perf: subj{np(str)} + {np(dat)}
odsłonić się: perf: subj{np(str)} + {prepnp(przed,inst)}
odsłonić się: perf: subj{np(str)} + {prepnp(wobec,gen)}
odstawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
odstawać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
odstawać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odstawać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)}
odstawać: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(od,gen)}
odstawać: imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,loc)}
odstawać: imperf: subj{np(str)} + {xp(adl)}
odstawać się: imperf: subj{np(str)}
odstawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
odstawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
odstawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odstawić się: perf: subj,controller{np(str)} + controllee{xp(mod)}
odstawić się: perf: subj{np(str)} + {prepnp(w,acc)}
odstąpić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
odstąpić: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
odstraszać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
odstraszać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
odstraszyć: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
odstraszyć: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
odsuwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odsuwać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
odsuwać się: imperf: subj{np(str)} + {prepnp(od,gen)}
odsuwać się: imperf: subj{np(str)} + {xp(adl)}
oduczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)}
oduczyć: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
oduczyć: perf: subj{np(str)} + obj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)} + {np(inst)}
oduczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
oduczyć się: perf: subj,controller{np(str)} + controllee{infp(imperf)} + {np(inst)}
oduczyć się: perf: subj{np(str)} + {cp(że)}
oduczyć się: perf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)} + {np(inst)}
oduczyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)}
odważyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
odważyć się: perf: subj,controller{np(str)} + controllee{infp(_)}
odważyć się: perf: subj{np(str)} + {cp(żeby)}
odważyć się: perf: subj{np(str)} + {or}
odważyć się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
odwdzięczyć się: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwdzięczyć się: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
odwiedzać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odwiedzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
odwołać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odwołać się: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
odwołać się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
odwołać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
odwołać się: perf: subj{np(str)} + {prepnp(od,gen)} + {prepncp(od,gen,że)}
odwracać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwracać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odwracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
odwracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odwracać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwracać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odwracać się: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
odwracać się: imperf: subj{np(str)} + {prepnp(na,loc)}
odwrócić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwrócić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odwrócić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
odwrócić się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odwrócić się: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
odwrócić się: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
odwrócić się: perf: subj{np(str)} + {prepnp(na,loc)}
odziedziczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
odznaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
odznaczać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
odznaczać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
odznaczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
odznaczyć się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
odznaczyć się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {xp(locat)}
odzwyczajać: imperf: subj,controller{np(str)} + controllee{infp(_)} + {np(inst)} + {refl}
odzwyczajać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)} + {refl}
odzwyczajać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(_)} + {np(inst)}
odzwyczajać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen); prepncp(od,gen,że)}
odzyskać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odzyskać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odzyskiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
odzyskiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
odzywać się: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)} + {or}
odzywać się: imperf: subj{np(str)} + controller{prepnp(o,loc)} + controllee{xp(mod)}
odzywać się: imperf: subj{np(str)} + {cp(że)}
odzywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
odzywać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
odzywać się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
odzywać się: imperf: subj{np(str)} + {prepnp(w,loc)}
odzywać się: imperf: subj{np(str)} + {xp(locat)} + {or}
odżywiać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
odżywiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
odżywiać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
odżywiać się: imperf: subj{np(str)} + {np(inst)}
oferować: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oferować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
oferować się: imperf: subj,controller{np(str)} + controllee{infp(_)}
oferować się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
oferować się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
ofiarować: _: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
ofiarować: _: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {refl}
ofiarować: _: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)}
ofiarować: _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ofiarować: _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
ofiarować: _: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
ofiarować: _: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
ofiarować się: _: subj,controller{np(str)} + controllee{infp(_)}
ofiarować się: _: subj{np(str)} + {cp(że)}
ofiarować się: _: subj{np(str)} + {or}
ofiarować się: _: subj{np(str)} + {prepnp(z,inst)}
ofiarowywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
ofiarowywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {refl}
ofiarowywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
ofiarowywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc)}
ofiarowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
ofiarowywać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
ofiarowywać się: imperf: subj{np(str)} + {cp(że)}
ofiarowywać się: imperf: subj{np(str)} + {or}
ofiarowywać się: imperf: subj{np(str)} + {prepnp(z,inst)}
ogarniać: imperf: subj{np(str)} + {np(inst)} + {refl}
ogarniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ogarniać się: imperf: subj{np(str)}
oglądać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oglądać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w roli)}
oglądać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
oglądać: imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
oglądać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
oglądać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
oglądać: imperf: subj{np(str)} + {xp(locat)} + {refl}
oglądać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
oglądać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
oglądać się: imperf: subj{np(str)} + {prepnp(za,inst)}
ogłaszać: imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
ogłaszać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
ogłaszać: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
ogłaszać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
ogłaszać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ogłaszać: imperf: subj{np(str)} + {or}
ogłaszać: imperf: subj{np(str)} + {prepnp(o,loc)}
ogłaszać się: imperf: subj{np(str)} + {or}
ogłosić: perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
ogłosić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
ogłosić: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
ogłosić: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
ogłosić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ogłosić: perf: subj{np(str)} + {or}
ogłosić: perf: subj{np(str)} + {prepnp(o,loc)}
ogolić: perf: subj{np(str)} + {np(inst)} + {advp(misc)} + {refl}
ogolić: perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
ogolić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
ogolić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ogolić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
ogolić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ograniczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ograniczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ograniczać: imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
ograniczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ograniczać się: imperf: subj{np(str)} + {np(inst)}
ograniczać się: imperf: subj{np(str)} + {prepncp(do,gen,że)}
ograniczać się: imperf: subj{np(str)} + {prepncp(do,gen,żeby)}
ograniczać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
ograniczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ograniczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ograniczyć: perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
ograniczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ograniczyć się: perf: subj{np(str)} + {np(inst)}
ograniczyć się: perf: subj{np(str)} + {prepncp(do,gen,że)}
ograniczyć się: perf: subj{np(str)} + {prepncp(do,gen,żeby)}
ograniczyć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
okazać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
okazać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
okazać się: perf: subj,controller{np(str)} + controllee{adjp(pred)}
okazać się: perf: subj,controller{np(str)} + controllee{infp(_)}
okazać się: perf: subj,controller{np(str)} + controllee{np(inst)}
okazać się: perf: subj{cp(int)}
okazać się: perf: subj{cp(że)}
okazywać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
okazywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
okazywać się: imperf: subj,controller{np(str)} + controllee{adjp(pred)}
okazywać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
okazywać się: imperf: subj,controller{np(str)} + controllee{np(inst)}
okazywać się: imperf: subj{cp(int)}
okazywać się: imperf: subj{cp(że)}
okładać: imperf: subj{np(str)} + {np(inst)} + {refl}
okładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
okładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
okładać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
okładać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
okradać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okradać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
okraść: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
okraść: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
określać: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
określać: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
określać: imperf: subj{np(str)} + {cp(int)}
określać: imperf: subj{np(str)} + {cp(że)}
określać: imperf: subj{np(str)} + {np(inst)} + {refl}
określać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
określać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
określać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
określać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
określić: perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
określić: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
określić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
określić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
określić: perf: subj{np(str)} + obj{cp(int)}
określić: perf: subj{np(str)} + obj{cp(że)}
określić się: perf: subj{np(str)} + {cp(int)}
określić się: perf: subj{np(str)} + {cp(że)}
okupować: imperf: subj{np(str)} + obj{np(str)}
omawiać: imperf: subj{np(str)} + obj{np(str)}
ominąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ominąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
ominąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
opadać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
opadać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
opadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
opadać: imperf: subj{np(str)} + {prepnp(o,acc)}
opalać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
opalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
opalać się: imperf: subj{np(str)}
opanować: perf: subj{np(str)} + obj{np(str)}
opanować się: perf: subj{np(str)}
opanowywać: imperf: subj{np(str)} + obj{np(str)}
opanowywać się: imperf: subj{np(str)}
opaść: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
opaść: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
opaść: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
opaść: perf: subj{np(str)} + {prepnp(o,acc)}
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)}
opiewać: imperf: subj{np(str)} + obj{np(str)}
opiewać: imperf: subj{np(str)} + {prepnp(na,acc)}
opiniować: imperf: subj{np(str)} + {cp(int)}
opiniować: imperf: subj{np(str)} + {cp(że)}
opiniować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
opiniować: imperf: subj{np(str)} + {or}
opisać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
opisać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
opisać: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
opisać: perf: subj{np(str)} + obj{ncp(str,int)} + {np(dat)}
opisać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
opisać: perf: subj{np(str)} + {or}
opisywać: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)}
opłacać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opłacać się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
opłacać się: imperf: subj{cp(żeby)} + {np(dat)}
opłacać się: imperf: subj{np(str)} + {np(dat)}
opłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
opłacić się: perf: subj,controllee{infp(_)} + controller{np(dat)}
opłacić się: perf: subj{cp(żeby)} + {np(dat)}
opłacić się: perf: subj{np(str)} + {np(dat)}
opłukać: perf: subj{np(str)} + {np(inst)} + {refl}
opłukać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opłukać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
opłukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
opłukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
opłukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
opłukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
opłukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
opłukać: perf: subj{np(str)} + {prepnp(pod,inst)} + {refl}
opłukać: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
opłukać: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
oponować: imperf: subj{np(str)} + {cp(jakoby)}
oponować: imperf: subj{np(str)} + {cp(że)}
oponować: imperf: subj{np(str)} + {cp(żeby)}
oponować: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
oponować: imperf: subj{np(str)} + {or}
oponować: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,jakoby); prepncp(przeciw,dat,że); prepncp(przeciw,dat,żeby)}
opowiadać: imperf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
opowiadać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
opowiadać: imperf: subj{np(str)} + {np(dat)} + {or}
opowiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
opowiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {nonch}
opowiadać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
opowiadać: imperf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
opowiedzieć: perf: subj{np(str)} + {np(dat)} + {comprepnp(na temat)} + {nonch}
opowiedzieć: perf: subj{np(str)} + {np(dat)} + {cp(int)}
opowiedzieć: perf: subj{np(str)} + {np(dat)} + {or}
opowiedzieć: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)}
opowiedzieć: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {nonch}
opowiedzieć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opowiedzieć: perf: subj{np(str)} + {prepnp(o,loc)} + {cp(że)}
opóźniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opóźniać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opóźniać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {comprepnp(z powodu)}
opóźniać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
opóźniać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
opóźnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opóźnić się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
opóźnić się: perf: subj{np(str)} + {prepnp(o,acc)} + {comprepnp(z powodu)}
opóźnić się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
opóźnić się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
opracować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
opracować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
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)}
orać: imperf: subj,controller{np(str)} + controllee{xp(mod)}
orać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
orać: imperf: subj{np(str)} + {prepnp(w,acc)}
orzec: perf: subj{np(str)} + {comprepnp(w sprawie)}
orzec: perf: subj{np(str)} + {cp(int)}
orzec: perf: subj{np(str)} + {cp(że)}
orzec: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
orzec: perf: subj{np(str)} + {or}
orzec: perf: subj{np(str)} + {prepnp(co do,gen)}
orzec: perf: subj{np(str)} + {prepnp(na,acc)}
orzec: perf: subj{np(str)} + {prepnp(o,loc)}
orzekać: imperf: subj{np(str)} + {comprepnp(w sprawie)}
orzekać: imperf: subj{np(str)} + {cp(int)}
orzekać: imperf: subj{np(str)} + {cp(że)}
orzekać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
orzekać: imperf: subj{np(str)} + {or}
orzekać: imperf: subj{np(str)} + {prepnp(co do,gen)}
orzekać: imperf: subj{np(str)} + {prepnp(na,acc)}
orzekać: imperf: subj{np(str)} + {prepnp(o,loc)}
osądzać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
osądzać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
osądzać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
osądzać: imperf: subj{np(str)} + {cp(int)}
osądzać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
osądzać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
osądzać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
osądzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
osądzać: imperf: subj{np(str)} + {or}
osądzić: perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
osądzić: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
osądzić: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
osądzić: perf: subj{np(str)} + {cp(int)}
osądzić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
osądzić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
osądzić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
osądzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
osądzić: perf: subj{np(str)} + {or}
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)}
osiedlić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
osiedlić się: perf: subj{np(str)} + {xp(locat)}
oskarżać: imperf: subj{np(str)} + {cp(że)} + {refl}
oskarżać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oskarżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(wobec,gen)}
oskarżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or}
oskarżać: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or} + {refl}
oskarżyć: perf: subj{np(str)} + {cp(że)} + {refl}
oskarżyć: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
oskarżyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(wobec,gen)}
oskarżyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or}
oskarżyć: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(przed,inst)} + {or} + {refl}
osłabiać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
osłabiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
osłabić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
osłabić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
osłaniać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
osłaniać: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
osłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
osłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
osłonić: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
osłonić: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {refl}
osłonić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
osłonić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
ostrzec: perf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
ostrzec: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepnp(przed,inst); prepncp(o,loc,że); prepncp(przed,inst,że)}
ostrzec: perf: subj{np(str)} + {or}
ostrzegać: imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
ostrzegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepnp(przed,inst); prepncp(o,loc,że); prepncp(przed,inst,że)}
ostrzegać: imperf: subj{np(str)} + {or}
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)}
oszaleć: perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
oszaleć: perf: subj{np(str)} + {prepnp(dla,gen)}
oszaleć: perf: subj{np(str)} + {prepnp(od,gen)}
oszaleć: perf: subj{np(str)} + {prepnp(za,inst)}
oszaleć: perf: subj{np(str)} + {prepnp(z,gen)}
oszczędzać: imperf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
oszczędzać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
oszczędzać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
oszczędzać: imperf: subj{np(str)} + {refl}
oszczędzić: perf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
oszczędzić: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
oszczędzić: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
oszczędzić: perf: subj{np(str)} + {refl}
oszukać: perf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
oszukać: perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
oszukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oszukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oszukać się: perf: subj{np(str)} + {prepnp(na,loc)}
oszukiwać: imperf: subj{np(str)} + {cp(że)} + {refl}
oszukiwać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
oszukiwać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
oszukiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
oszukiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
oszukiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
oszukiwać się: imperf: subj{np(str)} + {prepnp(na,loc)}
ośmielać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ośmielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ośmielać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
ośmielać się: imperf: subj{np(str)} + {prepnp(na,acc)}
ośmielić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
ośmielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ośmielić się: perf: subj,controller{np(str)} + controllee{infp(_)}
ośmielić się: perf: subj{np(str)} + {prepnp(na,acc)}
oświadczyć: perf: subj{np(str)} + {np(dat)} + {cp(int)}
oświadczyć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
oświadczyć: perf: subj{np(str)} + {np(dat)} + {or}
oświadczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
oświadczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc)}
oświadczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
oświadczyć: perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(że)}
oświadczyć: perf: subj{np(str)} + {prepnp(wobec,gen)} + {cp(żeby)}
oświadczyć: perf: subj{np(str)} + {prepnp(wobec,gen)} + {or}
oświadczyć się: perf: subj{np(str)} + {np(dat)}
oświadczyć się: perf: subj{np(str)} + {prepnp(o,acc)}
oświetlać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
oświetlić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otruć: perf: subj{np(str)} + {np(inst)} + {refl}
otruć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otrzeć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
otrzeć: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
otrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
otrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
otrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
otrzeć się: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
otrzeć się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
otrzeć się: perf: subj{np(str)} + {xp(locat)}
otrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
otrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
otrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
otrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
otrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
otulać: perf: subj{np(str)} + {np(inst)} + {refl}
otulać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otulać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
otulać: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
otulić: perf: subj{np(str)} + {np(inst)} + {refl}
otulić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
otulić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
otulić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
otulić: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
otworzyć: perf: subj,controller{np(str)} + controllee{xp(mod)}
otworzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
otworzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
otworzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
otworzyć się: perf: subj,controller{np(str)} + controllee{xp(mod)}
otworzyć się: perf: subj{np(str)} + {np(dat)}
owijać: imperf: subj{np(str)} + {np(inst)} + {refl}
owijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
owijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owijać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
owijać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owijać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owijać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owinąć: perf: subj{np(str)} + {np(inst)} + {refl}
owinąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
owinąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owinąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owinąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
owinąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owinąć: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
owinąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
owinąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
owinąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
owocować: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
ozdabiać: imperf: subj{np(str)} + {np(inst)} + {refl}
ozdabiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozdabiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ozdabiać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ozdobić: perf: subj{np(str)} + {np(inst)} + {refl}
ozdobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ozdobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ozdobić: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
oznaczać: imperf: subj{infp(_)} + {infp(_)}
oznaczać: imperf: subj{np(str)} + {cp(int)}
oznaczać: imperf: subj{np(str)} + {np(str); ncp(str,że)} + {prepnp(dla,gen)}
oznaczać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
oznaczać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oznaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
oznaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
oznaczać: imperf: subj{np(str)} + {or}
oznaczać: imperf: subj{np(str)} + {prepnp(dla,gen)} + {cp(że)}
oznaczyć: perf: subj{np(str)} + {cp(że)}
oznaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
oznaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
oznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
oznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
oznajmiać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
oznajmiać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że); cp(żeby)}
oznajmiać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
oznajmiać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
oznajmiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
oznajmić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
oznajmić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że); cp(żeby)}
oznajmić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {or}
oznajmić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
oznajmić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
ożenić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
ożenić się: perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
ożenić się: perf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
ożywiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ożywiać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
ożywić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
ożywić się: perf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnąć: imperf: controller{np(dat)} + controllee{infp(_)}
pachnąć: imperf: controller{xp(locat)} + controllee{xp(mod)}
pachnąć: imperf: {np(inst)} + {xp(locat)}
pachnąć: imperf: {prepnp(od,gen)} + {xp(locat)}
pachnąć: imperf: subj,controller{np(str)} + controllee{xp(mod)}
pachnąć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnąć: imperf: subj{np(str)} + {prepnp(od,gen)}
pachnieć: imperf: controller{np(dat)} + controllee{infp(_)}
pachnieć: imperf: controller{xp(locat)} + controllee{xp(mod)}
pachnieć: imperf: {np(inst)} + {xp(locat)}
pachnieć: imperf: {prepnp(od,gen)} + {xp(locat)}
pachnieć: imperf: subj,controller{np(str)} + controllee{xp(mod)}
pachnieć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
pachnieć: imperf: subj{np(str)} + {prepnp(od,gen)}
palnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
palnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
palnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
palnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
palnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
palnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
palnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
palnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
palnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
palnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
palnąć: perf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
palnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
palnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pamiętać: imperf: subj,controller{np(str)} + controllee{infp(_)}
pamiętać: imperf: subj{np(str)} + {cp(żeby)}
pamiętać: imperf: subj{np(str)} + {np(str); cp(int); cp(jak); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że); ncp(str,żeby2)}
pamiętać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
pamiętać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
pamiętać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pamiętać: imperf: subj{np(str)} + obj{np(str)}
pamiętać: imperf: subj{np(str)} + {prepnp(o,loc); cp(int); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
panować: imperf: subj{np(str)} + {np(dat)}
panować: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
panować: imperf: subj{np(str)} + {xp(locat)}
panować: imperf: subj{np(str)} + {xp(temp)}
paradować: imperf: subj{np(str)} + {xp(locat)}
paradować: imperf: subj{np(str)} + {xp(perl)}
parkować: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
parkować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pasać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pasjonować: imperf: subj{cp(int)} + {np(str)} + {prepnp(w,loc)}
pasjonować: imperf: subj{cp(że)} + {np(str)} + {prepnp(w,loc)}
pasjonować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
pasjonować się: imperf: subj{np(str)} + {cp(int)}
pasjonować się: imperf: subj{np(str)} + {cp(że)}
pasjonować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
pasować: imperf: subj,controllee{infp(_)} + controller{np(dat)}
pasować: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pasować: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)}
pasować: imperf: subj{cp(int)} + {np(dat)}
pasować: imperf: subj{cp(żeby)} + {np(dat)}
pasować: imperf: subj{cp(że)} + {np(dat)}
pasować: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
pasować: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pasować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(inst)}
paść: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
paść: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
paść: perf: {np(dat)} + {prepnp(na,acc)}
paść: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
paść: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
paść: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
paść: perf: subj{np(str)} + {or}
paść: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)}
paść: perf: subj{np(str)} + {prepnp(pod,inst)}
paść: perf: subj{np(str)} + {prepnp(z,gen)}
paść się: imperf: subj{np(str)} + {np(inst)}
paść się: imperf: subj{np(str)} + {prepnp(na,loc)}
patrolować: imperf: subj{np(str)} + {cp(czy)}
patrolować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
patrzeć: imperf: {np(dat)} + {advp(misc)} + {preplexnp(z,gen,pl,'oko',atr)}
patrzeć: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
patrzeć: imperf: subj{np(str)} + {cp(int)}
patrzeć: imperf: subj{np(str)} + {cp(jak)}
patrzeć: imperf: subj{np(str)} + {cp(że)}
patrzeć: imperf: subj{np(str)} + {cp(żeby)}
patrzeć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(w,acc)}
patrzeć: imperf: subj{np(str)} + {np(gen)}
patrzeć: imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
patrzeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(czy)}
patrzeć: imperf: subj{np(str)} + {prepnp(na,acc); cp(czy); cp(jak); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że)}
patrzeć: imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
patrzeć: imperf: subj{np(str)} + {prepnp(po,loc)}
patrzeć: imperf: subj{np(str)} + {prepnp(przez,acc)}
patrzeć: imperf: subj{np(str)} + {prepnp(za,inst)}
patrzeć się: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
patrzeć się: imperf: subj{np(str)} + {cp(int)}
patrzeć się: imperf: subj{np(str)} + {cp(jak); cp(że)}
patrzeć się: imperf: subj{np(str)} + {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)} + controllee{xp(mod)}
patrzyć: imperf: subj{np(str)} + {cp(int)}
patrzyć: imperf: subj{np(str)} + {cp(jak); cp(że)}
patrzyć: imperf: subj{np(str)} + {cp(żeby)}
patrzyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(w,acc)}
patrzyć: imperf: subj{np(str)} + {np(gen)}
patrzyć: imperf: subj{np(str)} + {prepncp(na,acc,żeby)}
patrzyć: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(czy)}
patrzyć: imperf: subj{np(str)} + {prepnp(na,acc); cp(czy); cp(jak); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że)}
patrzyć: imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
patrzyć: imperf: subj{np(str)} + {prepnp(po,loc)}
patrzyć: imperf: subj{np(str)} + {prepnp(przez,acc)}
patrzyć: imperf: subj{np(str)} + {prepnp(za,inst)}
patrzyć się: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
patrzyć się: imperf: subj{np(str)} + {cp(int)}
patrzyć się: imperf: subj{np(str)} + {cp(jak)}
patrzyć się: imperf: subj{np(str)} + {cp(że)}
patrzyć się: imperf: subj{np(str)} + {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)} + controllee{infp(_)}
pchać się: imperf: subj{np(str)} + {cp(żeby)}
pchać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pchać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pchać się: imperf: subj{np(str)} + {prepncp(do,gen,żeby)}
pchać się: imperf: subj{np(str)} + {prepnp(między,acc)}
pchać się: imperf: subj{np(str)} + {prepnp(na,acc)}
pchać się: imperf: subj{np(str)} + {xp(adl)}
pchnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
pchnąć: perf: subj{np(str)} + {np(str)} + {cp(żeby)}
pchnąć: perf: subj{np(str)} + {np(str)} + {prepncp(do,gen,żeby)}
pchnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pchnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pchnąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pełnić: imperf: subj{np(str)} + obj{np(str)}
penetrować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pękać: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pękać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pękać: imperf: subj{np(str)} + {prepnp(na,acc)}
pękać: imperf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'szew',natr)}
pęknąć: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pęknąć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
pęknąć: perf: subj{np(str)} + {prepnp(na,acc)}
pęknąć: perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,loc,pl,'szew',natr)}
piastować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
piąć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,loc)}
piąć się: imperf: subj{np(str)} + {prepnp(ku,dat)}
piąć się: imperf: subj{np(str)} + {prepnp(na,loc)}
piąć się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pić: imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
pić: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
pić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pić: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,jak); prepncp(do,gen,że); prepncp(do,gen,żeby)}
pić: imperf: subj{np(str)} + {prepnp(na,acc)}
pić: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
piec: imperf: {np(str)} + {xp(locat)}
piec: imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
piec: imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
piec: imperf: subj{np(str)} + obj{np(str)}
piec się: imperf: subj{np(str)}
pielęgnować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
pielęgnować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pieścić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pieścić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pieścić się: imperf: subj{np(str)} + {np(inst)}
pieścić się: imperf: subj{np(str)} + {prepnp(z,inst)}
piętnować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
piętnować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
pilnować: imperf: subj{np(str)} + obj{np(gen)} + {cp(int); cp(żeby)}
pilnować: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,że); ncp(gen,żeby)}
pilnować: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(przed,inst)}
pilnować się: imperf: subj{np(str)} + {cp(int)}
pilnować się: imperf: subj{np(str)} + {cp(żeby)}
pilnować się: imperf: subj{np(str)} + {np(gen)}
pisać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{np(nom)}
pisać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
pisać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pisać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pisać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
pisać: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(o,loc)}
pisać: imperf: subj{np(str)} + {np(dat)} + {or}
pisać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {cp(że)}
pisać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pisać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pisać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepadjp(po,postp)}
pisać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
pisać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
pisać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
pisać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pisać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
pisać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
pisać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pisać: imperf: subj{np(str)} + {prepnp(o,loc)} + {or}
pisać się: imperf: subj,controller{np(str)} + controllee{np(nom)}
pisać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
pisać się: imperf: subj{np(str)} + {xp(dur)}
pisnąć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
pisnąć: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
pisnąć: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',natr)} + {or}
pisnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
pisnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc)}
pisnąć: perf: subj{np(str)} + {prepnp(z,gen)}
planować: imperf: subj,controller{np(str)} + controllee{infp(_)}
planować: imperf: subj{np(str)} + {cp(int)}
planować: imperf: subj{np(str)} + {cp(żeby)}
planować: imperf: subj{np(str)} + obj{cp(że)}
planować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,acc)}
planować: imperf: subj{np(str)} + {or}
plątać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
plątać: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
plątać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
plątać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
plątać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
plątać się: imperf: subj{cp(że)} + {np(dat)} + {xp(locat)}
plątać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
plątać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
plątać się: imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
plątać się: imperf: subj{np(str)} + {prepnp(w,acc)}
plątać się: imperf: subj{np(str)} + {prepnp(w,loc)}
pleść: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
pleść: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
pleść: imperf: subj{np(str)} + {np(dat)} + {or}
pleść: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
pleść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pleść: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pleść się: imperf: subj{np(str)}
pleść się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
plotkować: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(z,inst)}
plotkować: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {cp(że)}
plotkować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
plotkować: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pluć: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
pluć: imperf: subj{np(str)} + {prepnp(na,acc)}
pluć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
pluć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,że)}
płacić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
płacić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
płakać: imperf: subj{np(str)} + {cp(int)}
płakać: imperf: subj{np(str)} + {cp(że)}
płakać: imperf: subj{np(str)} + {or}
płakać: imperf: subj{np(str)} + {prepncp(nad,inst,że)}
płakać: imperf: subj{np(str)} + {prepnp(na,acc)}
płakać: imperf: subj{np(str)} + {prepnp(nad,inst)}
płakać: imperf: subj{np(str)} + {prepnp(po,loc)}
płakać: imperf: subj{np(str)} + {prepnp(za,inst)}
pławić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pławić się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
pł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)}
pobawić: perf: subj{np(str)} + {np(str)}
pobawić się: perf: subj{np(str)} + {cp(że)}
pobawić się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pobawić się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
pobić: perf: subj{np(str)} + obj{np(str)} + {fixed('na kwaśne jabłko')}
pobić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
pobić się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
pobiec: perf: subj,controller{np(str)} + controllee{infp(_)} + {prepnp(do,gen)}
pobiec: perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
pobiec: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pobiec: perf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
pobiec: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pobiec: perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
pobiec: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
pobłogosławić: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
pobłogosławić: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
pobłogosławić: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
pobłogosławić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
pobłogosławić: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {refl}
pobrzmiewać: imperf: subj{np(str)} + {np(inst)}
pobrzmiewać: imperf: subj{np(str)} + {xp(locat)}
pobudować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pobudować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pobudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
pobudować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pobudować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pobudować się: perf: subj{np(str)} + {xp(locat)}
pocałować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pocałować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pocałować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pocałować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {preplexnp(z,gen,sg,'dubeltówka',natr)}
pocałować: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pocałować: perf: subj{np(str)} + {xp(locat)} + {refl}
pocałować się: perf: subj{np(str)} + {prepnp(z,inst)}
pochodzić: imperf: subj{np(str)} + {prepnp(od,gen)}
pochodzić: imperf: subj{np(str)} + {xp(abl)}
pochodzić: perf: subj{np(str)} + {prepnp(koło,gen)}
pochodzić: perf: subj{np(str)} + {prepnp(w,loc)}
pochodzić: perf: subj{np(str)} + {prepnp(za,inst)}
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)}
pochwycić: perf: subj{np(str)} + {cp(int)}
pochwycić: perf: subj{np(str)} + {cp(że)}
pochwycić: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
pochwycić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
pochwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
pochwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pochwycić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pochwycić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pochwycić: perf: subj{np(str)} + {or}
pociąć: perf: subj{np(str)} + {np(inst)} + {refl}
pociąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepnp(w,acc)}
pociąć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
pociągać: imperf: {np(inst)} + {xp(adl)}
pociągać: imperf: subj{cp(żeby)} + {np(str)}
pociągać: imperf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',natr)}
pociągać: imperf: subj{np(str)} + {lexnp(inst,sg,'nos',natr)} + {or}
pociągać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
pociągać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
pociągać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
pociągać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pociągać: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
pociągać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
pociągać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {preplexnp(z,inst,_,'siebie',natr)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'odpowiedzialność',atr)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,acc,sg,'język',natr)}
pociągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pociągnąć: perf: {np(inst)} + {xp(abl)}
pociągnąć: perf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',natr)}
pociągnąć: perf: subj{np(str)} + {lexnp(inst,sg,'nos',natr)} + {or}
pociągnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
pociągnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pociągnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
pociągnąć: perf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {preplexnp(za,acc,sg,'język',natr)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)} + {preplexnp(za,acc,sg,'język',natr)}
pociągnąć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)} + {preplexnp(za,inst,_,'siebie',natr)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'odpowiedzialność',atr)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
pociągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {xp(adl)}
pociągnąć: perf: subj{np(str)} + {xp(dur)}
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,controller{E} + controllee{infp(imperf)}
począć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
począć: perf: subj{np(str)} + {prepnp(z,inst)} + {nonch}
począć się: perf: subj{np(str)} + {prepnp(w,loc)}
począć się: perf: subj{np(str)} + {prepnp(z,gen)}
poczekać: perf: subj{np(str)} + {np(gen)}
poczekać: perf: subj{np(str)} + {prepnp(na,acc); cp(aż); cp(int); cp(jak); cp(kiedy); cp(że); cp(żeby); prepncp(na,acc,aż); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)} + {xp(dur)}
poczekać: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(aż)} + {xp(dur)}
poczekać: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
poczerwienieć: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
poczerwienieć: perf: subj{np(str)} + {prepnp(z,gen)}
poczęstować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poczęstować się: perf: subj{np(str)} + {np(inst)}
poczuć: perf: subj{np(str)} + {cp(int)}
poczuć: perf: subj{np(str)} + {cp(jak)}
poczuć: perf: subj{np(str)} + {cp(że)} + {lexnp(inst,sg,'nos',atr)} + {lexnp(str,sg,'pismo',natr)}
poczuć: perf: subj{np(str)} + {np(str); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że)}
poczuć: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
poczuć: perf: subj{np(str)} + {np(str)} + {prepnp(na,loc); prepnp(w,loc)}
poczuć: perf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
poczuć się: perf: subj,controller{np(str)} + controllee{adjp(pred)}
poczuć się: perf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(na,loc,pl,'siła',natr)}
poczuć się: perf: subj,controller{np(str)} + controllee{infp(_)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
poczuć się: perf: subj,controller{np(str)} + controllee{np(inst)}
poczuć się: perf: subj,controller{np(str)} + controllee{xp(mod)}
poczuć się: perf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
poczuć się: perf: subj{np(str)} + {np(gen)} + {preplexnp(w,loc,sg,'obowiązek',natr)}
poczuć się: perf: subj{np(str)} + {prepnp(do,gen)}
poczuwać: perf: subj{np(str)} + {prepnp(nad,inst)} + {xp(dur)}
poczuwać: perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
poczuwać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
poczuwać się: imperf: subj{np(str)} + {cp(żeby)}
poczuwać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
poczynać: perf: controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
poczynać: perf: subj,controller{E} + controllee{infp(imperf)}
poczynać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
poczynać się: perf: subj{np(str)} + {prepnp(w,loc)}
poczynać się: perf: subj{np(str)} + {prepnp(z,gen)}
poczynić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
poćwiczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
podać: perf: subj{np(str)} + {advp(pron)}
podać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
podać: perf: subj{np(str)} + obj{cp(int)}
podać: perf: subj{np(str)} + obj{cp(że)}
podać: perf: subj{np(str)} + obj{np(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)} + controllee{prepadjp(za,acc)}
podać się: perf: subj,controller{np(str)} + controllee{prepnp(za,acc)}
podać się: perf: subj{np(str)} + {prepnp(do,gen)}
podarować: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
podawać: imperf: subj{np(str)} + {advp(pron)}
podawać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
podawać: imperf: subj{np(str)} + obj{cp(int)}
podawać: imperf: subj{np(str)} + obj{cp(że)}
podawać: imperf: subj{np(str)} + obj{np(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)} + controllee{prepadjp(za,acc)}
podawać się: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)}
podawać się: imperf: subj{np(str)} + {prepnp(do,gen)}
podążać: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst); prepncp(za,inst,int)}
podążać: imperf: subj{np(str)} + {prepnp(do,gen)}
podążać: imperf: subj{np(str)} + {prepnp(ku,dat)}
podążać: imperf: subj{np(str)} + {xp(adl)}
podbić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
podbić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podbić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
podbić: perf: subj{np(str)} + {prepnp(do,gen)}
podbić: perf: subj{np(str)} + {xp(adl)}
podbić się: perf: subj{np(str)} + {prepnp(na,loc)}
podbijać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(o,acc)}
podbijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podbijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,jak); ncp(inst,że)}
podbijać: imperf: subj{np(str)} + {prepnp(do,gen)}
podbijać: imperf: subj{np(str)} + {xp(adl)}
podbijać się: imperf: subj{np(str)} + {prepnp(na,loc)}
podchodzić: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
podchodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podchodzić: imperf: subj{np(str)} + {np(inst)}
podchodzić: imperf: subj{np(str)} + obj{np(str)} + {or}
podchodzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
podchodzić: imperf: subj{np(str)} + {prepnp(pod,acc)}
podchodzić: imperf: subj{np(str)} + {xp(adl)}
podciąć: perf: {np(dat)} + {lexnp(str,pl,'noga',natr)}
podciąć: perf: subj{cp(gdy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: perf: subj{cp(jak)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: perf: subj{cp(kiedy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(str,pl,'skrzydło',natr)}
podciąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podcinać: imperf: {np(dat)} + {lexnp(str,pl,'noga',natr)}
podcinać: imperf: subj{cp(gdy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: imperf: subj{cp(jak)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: imperf: subj{cp(kiedy)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(str,pl,'skrzydło',natr)}
podcinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poddawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(pod,acc)}
poddawać: imperf: subj{np(str)} + {or}
poddawać się: imperf: subj{np(str)} + {np(dat)}
podejmować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
podejmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podejmować: imperf: subj{np(str)} + {or}
podejmować się: imperf: subj,controller{np(str)} + controllee{infp(_)}
podejmować się: imperf: subj{np(str)} + {cp(że)}
podejmować się: imperf: subj{np(str)} + {cp(żeby)}
podejmować się: imperf: subj{np(str)} + {np(gen)}
podejść: perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
podejść: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
podejść: perf: subj{np(str)} + {np(inst)}
podejść: perf: subj{np(str)} + {np(str)}
podejść: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
podejść: perf: subj{np(str)} + {prepnp(pod,acc)}
podejść: perf: subj{np(str)} + {xp(adl)}
podeprzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podeprzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
podeprzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podeprzeć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
podeprzeć się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
podeprzeć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
podeprzeć się: perf: subj{np(str)} + {prepnp(na,loc)}
poderwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
poderwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
poderwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
poderwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
poderwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
poderwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
poderwać się: perf: subj{np(str)} + {prepnp(do,gen)}
poderwać się: perf: subj{np(str)} + {prepnp(z,gen)}
poderwać się: perf: subj{np(str)} + {xp(abl)}
poderwać się: perf: subj{np(str)} + {xp(adl)}
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)} + controllee{infp(_)}
podjąć się: imperf: subj{np(str)} + {cp(że)}
podjąć się: imperf: subj{np(str)} + {cp(żeby)}
podjąć się: imperf: subj{np(str)} + {np(gen)}
podjechać: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podjechać: perf: subj{np(str)} + {np(inst)} + {np(str)}
podjechać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podjechać: perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)}
podjechać: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
podjechać: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
podjechać: perf: subj{np(str)} + {prepnp(ku,dat)}
podjechać: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podjeżdżać: perf: subj{np(str)} + {np(dat)} + {np(inst)}
podjeżdżać: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podjeżdżać: perf: subj{np(str)} + {np(inst)} + {np(str)}
podjeżdżać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podjeżdżać: perf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)}
podjeżdżać: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
podjeżdżać: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
podjeżdżać: perf: subj{np(str)} + {prepnp(ku,dat)}
podjeżdżać: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
podkładać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
podkładać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(pod,acc)}
podkładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podkładać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podkładać się: imperf: subj{np(str)} + {np(dat)}
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}
podlać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podlegać: imperf: subj{cp(int)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: imperf: subj{cp(że)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'dyskusja',atr)}
podlegać: imperf: subj{np(str)} + {np(dat)}
podlewać: imperf: subj{np(str)} + {np(inst)} + {refl}
podlewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podlewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podłączać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podłączać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłączać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłączyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podłączyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłączyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podłączyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
podłożyć: perf: subj{np(str)} + obj{np(part)} + {prepnp(do,gen)}
podłożyć: perf: subj{np(str)} + obj{np(part)} + {prepnp(pod,acc)}
podłożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podłożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
podłożyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podłożyć się: perf: subj{np(str)} + {np(dat)}
podnieść: perf: subj{np(str)} + {cp(że)}
podnieść: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'duch',natr)}
podnieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
podnieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podnieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
podnieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podnieść: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
podnieść: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
podnieść się: perf: subj{np(str)} + {prepnp(na,acc)}
podnieść się: perf: subj{np(str)} + {prepnp(o,acc)}
podnieść się: perf: subj{np(str)} + {prepnp(z,gen)}
podnieść się: perf: subj{np(str)} + {xp(abl)}
podobać się: imperf: controller{np(dat)} + controllee{infp(_)}
podobać się: imperf: {np(dat)} + {xp(locat)}
podobać się: imperf: subj{cp(gdy); ncp(str,gdy)} + {np(dat)}
podobać się: imperf: subj{cp(jak); ncp(str,jak); xp(locat)} + {np(dat)}
podobać się: imperf: subj{np(str); cp(jak); cp(że); ncp(str,jak); ncp(str,że)} + {np(dat)}
podołać: perf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
podpalić: perf: subj{np(str)} + {np(inst)} + {refl}
podpalić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podpierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podpierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
podpierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podpierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
podpierać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
podpierać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
podpierać się: imperf: subj{np(str)} + {prepnp(na,loc)}
podpisać: perf: subj,controller{np(str)} + obj{np(str)} + controllee{np(str)}
podpisać: perf: subj,controller{np(str)} + obj{np(str)} + controllee{prepnp(jako,str)} + {np(inst)}
podpisać: perf: subj{np(str)} + obj{cp(że)}
podpisać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podpisać się: perf: subj,controller{np(str)} + controllee{np(str)} + {prepnp(na,loc)}
podpisać się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)}
podpisać się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
podpisać się: perf: subj{np(str)} + {np(inst)} + {prepnp(pod,inst); prepncp(pod,inst,że); prepncp(pod,inst,żeby)}
podpisać się: perf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
podpisywać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{np(str)}
podpisywać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{prepnp(jako,str)} + {np(inst)}
podpisywać: imperf: subj{np(str)} + obj{cp(że)}
podpisywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
podpisywać się: imperf: subj,controller{np(str)} + controllee{np(str)} + {prepnp(na,loc)}
podpisywać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {prepnp(na,loc)}
podpisywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
podpisywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,inst); prepncp(pod,inst,że); prepncp(pod,inst,żeby)}
podpisywać się: imperf: subj{np(str)} + {prepnp(na,loc)} + {cp(że)}
podporządkować: perf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podporządkować się: perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
podporządkować się: perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
podporządkować się: perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podporządkowywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podporządkowywać się: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
podporządkowywać się: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
podporządkowywać się: imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
podpowiadać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
podpowiadać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
podpowiadać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podpowiadać: imperf: subj{np(str)} + {np(dat)} + {or}
podpowiadać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
podrapać: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
podrapać: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
podrapać: perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
podrapać: perf: subj{np(str)} + {np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
podrapać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrapać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
podrapać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
podrapać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
podrapać się: perf: subj{np(str)} + {prepnp(o,acc)}
podrożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podróżować: imperf: subj,controller{np(str)} + controllee{xp(mod)}
podróżować: imperf: subj{np(str)} + {np(inst)}
podróżować: imperf: subj{np(str)} + {prepnp(między,inst)}
podróżować: imperf: subj{np(str)} + {prepnp(na,acc)}
podróżować: imperf: subj{np(str)} + {xp(abl); xp(adl)}
podróżować: imperf: subj{np(str)} + {xp(perl)}
podróżować: perf: subj{np(str)} + obj{np(str)}
podrywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
podrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
podrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
podrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
podrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
podrywać się: imperf: subj{np(str)} + {prepnp(do,gen)}
podrywać się: imperf: subj{np(str)} + {prepnp(z,gen)}
podrywać się: imperf: subj{np(str)} + {xp(abl)}
podrywać się: imperf: subj{np(str)} + {xp(adl)}
podrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podrzeć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
podrzeć się: perf: subj{np(str)} + {xp(dur)}
podrzucać: imperf: subj{E} + {np(str)} + {xp(adl)}
podrzucać: imperf: subj{np(str)} + {cp(że)}
podrzucać: imperf: subj{np(str)} + obj{np(inst)}
podrzucać: imperf: subj{np(str)} + obj{np(part)} + {xp(adl)}
podrzucać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podrzucić: perf: subj{E} + {np(str)} + {xp(adl)}
podrzucić: perf: subj{np(str)} + {cp(że)}
podrzucić: perf: subj{np(str)} + obj{np(inst)}
podrzucić: perf: subj{np(str)} + obj{np(part)} + {xp(adl)}
podrzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
podskakiwać: imperf: subj{np(str)} + {np(dat)}
podskakiwać: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
podskakiwać: imperf: subj{np(str)} + {prepnp(do,gen)}
podskakiwać: imperf: subj{np(str)} + {prepnp(o,acc)}
podskoczyć: perf: subj{np(str)} + {np(dat)}
podskoczyć: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
podskoczyć: perf: subj{np(str)} + {prepnp(do,gen)}
podskoczyć: perf: subj{np(str)} + {prepnp(o,acc)}
podsłuchać: imperf: subj{np(str)} + {cp(że)}
podsłuchać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
podsłuchać: imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podsłuchiwać: imperf: subj{np(str)} + {cp(że)}
podsłuchiwać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
podsłuchiwać: imperf: subj{np(str)} + obj{np(str)} + {cp(jak)}
podsumować: perf: subj{np(str)} + {cp(int)}
podsumować: perf: subj{np(str)} + {cp(że)}
podsumować: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
podsumować: perf: subj{np(str)} + {or}
podsumowywać: imperf: subj{np(str)} + {cp(int)}
podsumowywać: imperf: subj{np(str)} + {cp(że)}
podsumowywać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
podsumowywać: imperf: subj{np(str)} + {or}
podsunąć: perf: subj{np(str)} + {np(dat)} + {cp(int)}
podsunąć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
podsunąć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podsunąć: perf: subj{np(str)} + {np(dat)} + {or}
podsunąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podsunąć się: perf: subj{np(str)} + {prepnp(do,gen)}
podsunąć się: perf: subj{np(str)} + {xp(adl)}
podsuwać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
podsuwać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
podsuwać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
podsuwać: imperf: subj{np(str)} + {np(dat)} + {or}
podsuwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
podsuwać się: imperf: subj{np(str)} + {prepnp(do,gen)}
podsuwać się: imperf: subj{np(str)} + {xp(adl)}
podszywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podszywać się: imperf: subj{np(str)} + {prepnp(pod,acc)}
podważać: imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
podważać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podważyć: perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)}
podważyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
podwyższać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podwyższać się: imperf: subj{np(str)} + {prepnp(o,acc)}
podwyższyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
podwyższyć się: perf: subj{np(str)} + {prepnp(o,acc)}
podyskutować: perf: subj{np(str)} + {prepnp(nad,inst); prepnp(o,loc); comprepnp(na temat); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
podyskutować: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
podyskutować: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
podyskutować: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
podziać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
podziać się: perf: subj{np(str)} + {advp(misc)}
podziać się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
podziać się: perf: {xp(locat)} + {advp(misc)}
podziałać: perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)} + {np(inst)}
podziałać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
podzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
podzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
podzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
podzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
podzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
podzielić się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {or}
podzielić się: perf: subj{np(str)} + {prepnp(na,acc)}
podziękować: perf: subj{np(str)} + {np(dat)} + {or}
podziękować: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); cp(że); prepncp(za,acc,że)}
podziwiać: imperf: subj{np(str)} + {cp(jak)}
podziwiać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
podziwiać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
podziwiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
podziwiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
podziwiać: imperf: subj{np(str)} + {xp(locat)} + {refl}
podźwignąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
podźwignąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
podźwignąć: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
podźwignąć: perf: subj{np(str)} + {xp(abl)} + {refl}
pofatygować: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pofatygować się: perf: subj,controller{np(str)} + controllee{infp(_)}
pofatygować się: perf: subj{np(str)} + {cp(żeby)}
pofatygować się: perf: subj{np(str)} + {np(inst)}
pofatygować się: perf: subj{np(str)} + {prepnp(do,gen)}
pofatygować się: perf: subj{np(str)} + {prepnp(na,acc)}
pofatygować się: perf: subj{np(str)} + {prepnp(z,inst)}
pofatygować się: perf: subj{np(str)} + {xp(adl)}
pogadać: perf: subj,controller{np(str)} + controllee{xp(mod)}
pogadać: perf: subj{np(str)} + {prepnp(do,gen)}
pogadać: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {prepnp(z,inst)}
pogadać: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pogadać: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pogadać: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
pogadać: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
pogarszać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogarszać się: imperf: {np(dat)}
pogarszać się: imperf: subj{np(str)} + {np(dat)}
pogładzić: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pogładzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogładzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pogłaskać: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
pogłaskać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogłaskać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
pogłębiać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
pogłębiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogłębiać się: imperf: subj{np(str)} + {np(dat)}
pogłębiać się: imperf: subj{np(str)} + {prepnp(w,loc)}
pogłębić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
pogłębić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogłębić się: perf: subj{np(str)} + {np(dat)}
pogłębić się: perf: subj{np(str)} + {prepnp(w,loc)}
pognać: perf: {np(str)} + {prepnp(do,gen)}
pognać: perf: {np(str)} + {xp(abl)} + {xp(adl)}
pognać: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pognać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pognać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
pogodzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
pogodzić się: perf: subj{np(str)} + {cp(że)}
pogodzić się: perf: subj{np(str)} + {prepncp(z,inst,żeby2)}
pogodzić się: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
pogonić: perf: {np(str)} + {xp(adl)}
pogonić: perf: subj{np(str)} + {np(dat)} + {lexnp(acc,sg,'kot',natr)}
pogonić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pogonić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pogonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pogonić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
pogonić: perf: subj{np(str)} + {prepnp(za,inst)}
pogorszyć: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst)}
pogorszyć się: perf: {np(dat)}
pogorszyć się: perf: subj{np(str)} + {np(dat)}
pogratulować: perf: subj{np(str)} + {np(dat)} + {np(gen); cp(że); ncp(gen,że)}
pogryźć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pogryźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pogryźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
pogryźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pogryźć: perf: subj{np(str)} + {prepnp(po,loc)} + {refl}
pogryźć: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
pogryźć się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pogubić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pogubić się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pogubić się: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
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)} + controllee{prepadjp(jako,str)}
pojmować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
pojmować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
pokazać: perf: subj{np(str)} + controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {np(inst)}
pokazać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)}
pokazać: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pokazać: perf: subj{np(str)} + {np(str)} + {preplexnp(po,loc,_,'siebie',natr)}
pokazać się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
pokazać się: perf: subj{np(str)} + {cp(że)}
pokazać się: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,pl,'oko',natr)}
pokazać się: perf: subj{np(str)} + {np(dat)} + {preplexnp(od,gen,sg,'strona',ratr)}
pokazać się: perf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,sg,'strona',ratr)}
pokazać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pokazać się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
pokazać się: perf: subj{np(str)} + {prepnp(z,inst)}
pokazywać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
pokazywać: imperf: subj{np(str)} + {np(str)} + {preplexnp(po,loc,_,'siebie',natr)}
pokazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {np(inst)}
pokazywać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
pokazywać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
pokazywać się: imperf: subj{cp(że)}
pokazywać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,pl,'oko',natr)}
pokazywać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(od,gen,sg,'strona',ratr)}
pokazywać się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(z,gen,sg,'strona',ratr)}
pokazywać się: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
pokazywać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
pokazywać się: imperf: subj{np(str)} + {prepnp(z,inst)}
pokierować: perf: subj{np(str)} + obj{np(inst)}
pokierować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); xp(adl)}
pokierować: perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
pokierować się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
pokiwać: perf: subj{np(str)} + {np(dat)} + {np(inst)}
pokiwać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
pokiwać: perf: subj{np(str)} + {np(inst)} + {prepnp(ku,dat)}
pokiwać: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
pokiwać się: perf: subj{np(str)}
poklepać: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
poklepać: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
poklepać: perf: subj{np(str)} + {np(inst)} + {xp(locat)} + {refl}
poklepać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
poklepać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
poklepać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
pokładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
pokładać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pokładać się: imperf: subj{np(str)} + {xp(locat)}
pokłócić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pokłócić się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(z powodu)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
pokłócić się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
pokręcić: perf: {np(str)}
pokręcić: perf: subj{np(str)} + {np(inst)}
pokręcić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pokręcić się: perf: {np(dat)} + {prepnp(od,gen)} + {prepnp(w,loc)}
pokręcić się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pokręcić się: perf: subj{np(str)} + {prepnp(koło,gen)}
pokręcić się: perf: subj{np(str)} + {prepnp(na,loc)}
pokręcić się: perf: subj{np(str)} + {prepnp(wokół,gen)}
pokręcić się: perf: subj{np(str)} + {xp(locat)}
pokroić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pokroić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
pokrzyżować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pokrzyżować się: perf: subj{np(str)} + {np(dat)}
pokrzyżować się: perf: subj{np(str)} + {prepnp(z,inst)}
pokusić: perf: subj{cp(żeby)} + {np(str)}
pokusić: perf: subj{infp(_)} + {np(str)}
pokusić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pokusić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pokusić się: perf: subj,controller{np(str)} + controllee{infp(_)}
pokusić się: perf: subj{np(str)} + {cp(żeby)}
pokusić się: perf: subj{np(str)} + {prepnp(do,gen)}
pokusić się: perf: subj{np(str)} + {prepnp(na,acc)}
pokusić się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
pokutować: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
pokutować: imperf: subj{np(str)} + {prepnp(u,gen)}
pokutować: imperf: subj{np(str)} + {prepnp(w,loc)}
pokutować: imperf: subj{np(str)} + {prepnp(wśród,gen)}
pokutować: imperf: subj{np(str)} + {xp(locat)}
pokwitować: perf: subj{np(str)} + {np(inst)} + {cp(że)}
pokwitować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
polać: perf: subj{np(str)} + {np(inst)} + {refl}
polać: perf: subj{np(str)} + obj{np(part)} + {np(dat)}
polać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
polec: perf: subj{np(str)} + {prepnp(od,gen)}
polec: perf: subj{np(str)} + {prepnp(za,acc)}
polecać: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
polecać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
polecać: imperf: subj{np(str)} + {np(dat)} + {or}
polecać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
polecać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
polecać: imperf: subj{np(str)} + obj,controllee{np(str); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)}
polecać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
polecać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
polecać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
polecać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
polecać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(na,acc,sg,'przyszłość',natr)}
polecić: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
polecić: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
polecić: imperf: subj{np(str)} + {np(dat)} + {or}
polecić: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
polecić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
polecić: imperf: subj{np(str)} + obj,controllee{np(str); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)}
polecić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
polecić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
polecić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
polecić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
polecić się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {preplexnp(na,acc,sg,'przyszłość',natr)}
polecieć: perf: subj,controller{np(str)} + controllee{infp(_)}
polecieć: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
polecieć: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
polecieć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {or}
polecieć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
polecieć: perf: subj{np(str)} + {prepnp(na,acc)}
polecieć: perf: subj{np(str)} + {prepnp(po,acc)}
polecieć: perf: subj{np(str)} + {prepnp(za,inst)}
polegać: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
polemizować: imperf: subj{np(str)} + {cp(int)}
polemizować: imperf: subj{np(str)} + {cp(że)}
polemizować: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
polemizować: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
polemizować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
polemizować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
polemizować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
polemizować: imperf: subj{np(str)} + {prepnp(z,inst)} + {or}
polewać: imperf: subj{np(str)} + {np(inst)} + {refl}
polewać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
polewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
polewać: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,jak); prepncp(z,gen,że)}
policzyć: perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
policzyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
policzyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)} + {np(dat)}
policzyć: perf: subj{np(str)} + obj{cp(int)}
policzyć: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
policzyć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
policzyć: perf: subj{np(str)} + {prepnp(do,gen)}
policzyć się: perf: subj{np(str)} + {prepnp(z,inst)}
polować: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
polubić: perf: subj,controller{np(str)} + controllee{infp(_)}
polubić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
polubić się: perf: subj{np(str)} + {prepnp(z,inst)}
połamać: perf: {np(str)} + {prepnp(w,loc)}
połamać: perf: subj{np(str)} + {cp(int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
połamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
połamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
połamać: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,_,'głowa',natr)}
połamać: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)} + {lexnp(dat,_,'siebie',natr)} + {lexnp(str,pl,'ząb',atr)}
połamać się: perf: subj{np(str)} + {np(dat)}
połamać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
połapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
połapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
połapać się: perf: subj{np(str)} + {cp(int)}
połapać się: perf: subj{np(str)} + {cp(że)}
połapać się: perf: subj{np(str)} + {prepnp(na,loc)}
połapać się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
połączyć: perf: subj{np(str)} + 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łyskiwać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pomachać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)}
pomachać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
pomachać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
pomachać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
pomachać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
pomachać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(że)}
pomachać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {cp(żeby)}
pomachać: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(że)}
pomachać: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {cp(żeby)}
pomagać: imperf: subj{cp(że)} + {np(dat)}
pomagać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
pomagać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
pomagać: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pomagać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pomagać: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
pomagać: imperf: subj{np(str)} + {prepnp(na,acc)}
pomieszać: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
pomieszać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pomieszać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pomieszać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
pomieszać się: perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',atr)}
pomieszać się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pomieścić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pomieścić się: perf: subj{cp(int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: perf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: perf: subj{ncp(str,int)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: perf: subj{ncp(str,żeby)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: perf: subj{ncp(str,że)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
pomieścić się: perf: subj{np(str)} + {xp(locat)}
pomodlić się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,że); prepncp(o,acc,żeby); prepncp(za,acc,że); prepncp(za,acc,żeby)} + {or}
pomodlić się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {cp(żeby)}
pomodlić się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,inst)} + {cp(żeby)}
pomóc: perf: subj{cp(że)} + {np(dat)}
pomóc: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
pomóc: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
pomóc: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pomóc: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pomóc: perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
pomóc: perf: subj{np(str)} + {prepnp(na,acc)}
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)} + controllee{xp(mod)}
pomyśleć: perf: subj{np(str)} + {or}
pomyśleć: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
pomyśleć: perf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
pomyśleć: perf: subj{np(str)} + {prepnp(o,loc)} + {nonch}
ponawiać: imperf: subj{np(str)} + obj{np(str)}
ponawiać się: imperf: subj{np(str)}
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)}
ponowić: perf: subj{np(str)} + obj{np(str)}
ponowić się: perf: subj{np(str)}
pooglądać: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
pooglądać: perf: subj{np(str)} + obj{np(str)} + {cp(jak)}
pooglądać: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
pooglądać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
pooglądać: perf: subj{np(str)} + {xp(locat)} + {refl}
pooglądać się: perf: subj{np(str)} + {prepnp(za,inst)}
popadać: imperf: subj{np(str)} + {prepnp(u,gen)} + {preplexnp(w,acc,sg,'niełaska',natr)}
popadać: imperf: subj{np(str)} + {prepnp(w,acc)}
popadać: perf: subj{E}
popadać: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
popadać: perf: subj{np(str)} + {prepnp(od,gen)}
popadać: perf: subj{np(str)} + {prepnp(z,gen)}
popadać: perf: subj{np(str)} + {xp(adl)}
popaść: perf: subj{np(str)} + {np(dat)}
popaść: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popaść: perf: subj{np(str)} + {prepnp(u,gen)} + {preplexnp(w,acc,sg,'niełaska',natr)}
popaść: perf: subj{np(str)} + {prepnp(w,acc)}
popaść się: perf: subj{np(str)} + {np(inst)}
popaść się: perf: subj{np(str)} + {prepnp(na,loc)}
popatrzeć: perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
popatrzeć: perf: subj{np(str)} + {cp(jak)}
popatrzeć: perf: subj{np(str)} + {cp(że)}
popatrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
popatrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzeć: perf: subj{np(str)} + {prepnp(na,acc); prepnp(po,loc); prepnp(w,acc); cp(int); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że); xp(locat)}
popatrzeć: perf: subj{np(str)} + {prepnp(przez,acc)}
popatrzeć się: perf: subj{np(str)} + {cp(int)}
popatrzeć się: perf: subj{np(str)} + {cp(jak)}
popatrzeć się: perf: subj{np(str)} + {cp(że)}
popatrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzeć się: perf: subj{np(str)} + {prepnp(na,acc)}
popatrzeć się: perf: subj{np(str)} + {prepnp(po,loc)}
popatrzeć się: perf: subj{np(str)} + {prepnp(przez,acc)}
popatrzyć: perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
popatrzyć: perf: subj{np(str)} + {cp(jak)}
popatrzyć: perf: subj{np(str)} + {cp(że)}
popatrzyć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
popatrzyć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzyć: perf: subj{np(str)} + {prepnp(na,acc); prepnp(po,loc); prepnp(w,acc); cp(int); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,że); xp(locat)}
popatrzyć: perf: subj{np(str)} + {prepnp(przez,acc)}
popatrzyć się: perf: subj{np(str)} + {cp(int)}
popatrzyć się: perf: subj{np(str)} + {cp(jak)}
popatrzyć się: perf: subj{np(str)} + {cp(że)}
popatrzyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
popatrzyć się: perf: subj{np(str)} + {prepnp(na,acc)}
popatrzyć się: perf: subj{np(str)} + {prepnp(po,loc)}
popatrzyć się: perf: subj{np(str)} + {prepnp(przez,acc)}
popełniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popełnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
popijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
popisać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
popisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
popisać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
popisać: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
popisać: perf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)} + {xp(locat)}
popisać się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
popisać się: perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {or}
popisać się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
popisać się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
popisywać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
popisywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {or}
popisywać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
popisywać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
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)}
poprzedzić: perf: subj{ncp(str,że)} + obj{np(str)}
poprzedzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
popsuć: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
popsuć się: perf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
popsuć się: perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
popsuć się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pora: imperf: controller{np(dat)} + controllee{infp(_)}
pora: imperf: {cp(żeby)}
pora: imperf: {prepnp(na,acc); prepncp(na,acc,żeby)}
pora: imperf: {xp(adl)}
poradzić: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
poradzić: perf: subj{np(str)} + {np(dat)} + {cp(int)}
poradzić: perf: subj{np(str)} + {np(dat)} + {or}
poradzić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {nonch}
poradzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
poradzić: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że); prepncp(z,inst,żeby)} + {lexnp(dat,_,'siebie',natr)}
poradzić się: perf: subj{np(str)} + {np(gen)} + {comprepnp(na temat)}
poradzić się: perf: subj{np(str)} + {np(gen)} + {comprepnp(w kwestii)}
poradzić się: perf: subj{np(str)} + {np(gen)} + {comprepnp(w sprawie)}
poradzić się: perf: subj{np(str)} + {np(gen)} + {cp(int)}
poradzić się: perf: subj{np(str)} + {np(gen)} + {preplexnp(w,loc,sg,'temat',atr)}
porobić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
porobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
porobić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
porobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
porobić: perf: subj{np(str)} + {prepnp(w,acc)}
porobić się: perf: {np(dat)} + {advp(misc)}
porobić się: perf: {prepnp(z,inst)} + {advp(misc)}
porobić się: perf: subj,controller{np(str)} + controllee{adjp(pred)}
porobić się: perf: subj,controller{np(str)} + controllee{np(inst)}
porobić się: perf: subj{nonch} + {prepnp(z,inst)}
porobić się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
porobić się: perf: subj{np(str)} + {prepnp(z,gen)}
porobić się: perf: {xp(locat)} + {advp(misc)}
porozmawiać: perf: subj{np(str)} + {prepnp(o,loc); comprepnp(na temat); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
porozmawiać: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
porozmawiać: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
porozmawiać: perf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(o,loc,żeby)}
porozumieć się: perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
porozumieć się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
porozumieć się: perf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
porozumiewać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
porozumiewać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
porozumiewać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
porównać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int)}
porównać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
porównać: perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
porównać: perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
poruszać: imperf: subj{cp(że)} + {np(str)}
poruszać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
poruszać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
poruszać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
poruszać: perf: subj{np(str)} + {np(inst)} + {np(str)}
poruszać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(w,loc)}
poruszać się: imperf: subj{np(str)} + {np(inst)}
poruszać się: imperf: subj{np(str)} + {prepnp(na,loc)}
poruszać się: imperf: subj{np(str)} + {prepnp(o,loc)}
poruszać się: perf: subj{np(str)}
poruszyć: perf: subj{cp(że)} + {np(str)}
poruszyć: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
poruszyć: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
poruszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
poruszyć się: perf: subj{np(str)}
porwać: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
porwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
porwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
porwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
porwać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
porwać się: perf: subj{np(str)} + {np(dat)}
porwać się: perf: subj{np(str)} + {prepnp(do,gen)}
porwać się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
porwać się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
porwać się: perf: subj{np(str)} + {prepnp(za,acc)}
porwać się: perf: subj{np(str)} + {xp(abl)}
porywać: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
porywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
porywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
porywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
porywać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
porywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
porywać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
porywać się: imperf: subj{np(str)} + {np(dat)}
porywać się: imperf: subj{np(str)} + {prepnp(do,gen)}
porywać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
porywać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
porywać się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
porywać się: imperf: subj{np(str)} + {prepnp(za,acc)}
porywać się: imperf: subj{np(str)} + {xp(abl)}
porządkować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
porządkować się: imperf: subj{np(str)}
porzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
porzucać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
porzucać: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
porzucać: perf: subj{np(str)} + {np(str)} + {xp(adl)}
porzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
porzucić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
posadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
posadzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
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)}
poskarżyć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int)}
poskarżyć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
poskarżyć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int)}
poskarżyć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
poskarżyć: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
poskarżyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int); cp(że)}
poskarżyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
poskarżyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
poskarżyć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int); cp(że)}
poskarżyć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {or}
poskarżyć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
poskarżyć się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
poskarżyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
poskarżyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {or}
posłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
posłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
posłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)}
posłać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
posłuchać: imperf: subj{np(str)} + {cp(int)}
posłuchać: imperf: subj{np(str)} + {cp(że)}
posłuchać: imperf: subj{np(str)} + {np(gen); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
posłuchać: imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
posłuchać: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)} + {np(inst)}
posłuchać się: imperf: subj{np(str)} + {np(gen)}
posługiwać: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
posługiwać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
posługiwać: imperf: subj{np(str)} + {prepnp(na,loc)}
posługiwać: imperf: subj{np(str)} + {prepnp(u,gen)}
posługiwać się: imperf: subj{np(str)} + {np(inst)}
posłużyć: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
posłużyć: perf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {np(dat)}
posłużyć: perf: subj{np(str)} + {np(dat)} + {np(inst)}
posłużyć: perf: subj{np(str)} + {np(dat)} + {prepnp(dla,gen)}
posłużyć: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
posłużyć: perf: subj{np(str)} + {prepnp(w,loc)}
posłużyć się: perf: subj{np(str)} + {np(inst)}
posłyszeć: perf: subj{np(str)} + {cp(int)}
posłyszeć: perf: subj{np(str)} + {cp(jak)}
posłyszeć: perf: subj{np(str)} + {cp(że)}
posłyszeć: perf: subj{np(str)} + obj{np(str)}
posłyszeć: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
posmakować: perf: subj{np(str)} + {cp(int)}
posmakować: perf: subj{np(str)} + {np(dat)}
posmakować: perf: subj{np(str)} + obj{np(gen); ncp(gen,int)}
posolić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
posolić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
posolić: perf: subj{np(str)} + {refl}
postanawiać: imperf: subj,controller{np(str)} + controllee{infp(_)}
postanawiać: imperf: subj{np(str)} + obj{cp(int)}
postanawiać: imperf: subj{np(str)} + obj{cp(że)}
postanawiać: imperf: subj{np(str)} + obj{cp(żeby)}
postanawiać: imperf: subj{np(str)} + obj{np(str)}
postanawiać: imperf: subj{np(str)} + {or}
postanawiać: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
postanowić: perf: subj,controller{np(str)} + controllee{infp(_)}
postanowić: perf: subj{np(str)} + obj{cp(int)}
postanowić: perf: subj{np(str)} + obj{cp(że)}
postanowić: perf: subj{np(str)} + obj{cp(żeby)}
postanowić: perf: subj{np(str)} + obj{np(str)}
postanowić: perf: subj{np(str)} + {or}
postanowić: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
postarać się: perf: subj,controller{np(str)} + controllee{prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby); infp(_)}
postawić: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {cp(że)}
postawić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
postawić: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {prepnp(za,acc)}
postawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
postawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,sg,'pręgierz',ratr)}
postawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',ratr)}
postawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
postawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
postawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
postawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
postawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
postawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
postawić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
postawić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
postawić: perf: subj{np(str)} + {prepadjp(na,loc)}
postawić: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
postawić: perf: subj{np(str)} + {prepnp(za,acc)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
postawić: perf: subj{np(str)} + {prepnp(za,acc)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
postawić: perf: subj{np(str)} + {prepnp(za,acc)} + {infp(_)} + {lexnp(dat,_,'siebie',natr)}
postawić się: perf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
postawić się: perf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(inst,sg,'sztorc',natr)}
postawić się: perf: subj{np(str)} + {prepnp(w,loc)}
postawić się: perf: subj{np(str)} + {prepnp(wobec,gen)}
postępować: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(wobec,gen)}
postępować: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(względem,gen)}
postępować: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
postępować: imperf: subj{np(str)} + controller{prepnp(z,inst)} + controllee{xp(mod)}
postępować: imperf: subj{np(str)} + {np(inst)}
postępować: imperf: subj{np(str)} + {np(str)} + {prepnp(za,inst)}
postępować: imperf: subj{np(str)} + {np(str)} + {xp(adl)}
postępować: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(za,inst)}
postępować: imperf: subj{np(str)} + {prepnp(według,gen)}
postulować: imperf: subj{np(str)} + obj{cp(żeby)}
postulować: imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)}
postulować: imperf: subj{np(str)} + {or}
posunąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
posunąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
posunąć się: perf: subj,controller{np(str)} + controllee{xp(mod)}
posunąć się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
posunąć się: perf: subj{np(str)} + {prepnp(ku,dat)}
posunąć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
posunąć się: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
posuwać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)} + {xp(perl)}
posuwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
posuwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
posuwać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
posuwać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
posuwać się: imperf: subj{np(str)} + {prepnp(ku,dat)}
posuwać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
posuwać się: imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
posypać: perf: subj{np(str)} + {np(inst)} + {refl}
posypać: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
posypać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
posypać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
posypać się: perf: subj{np(str)} + {prepnp(na,acc)}
poszczycić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
poszczycić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
poszczycić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
poszerzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int)}
poszerzać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poszerzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int)}
poszerzyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
poszukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
poszukać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
poszukać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
poszukiwać: imperf: subj{np(str)} + obj{np(gen)} + {np(dat)} + {xp(locat)}
poszukiwać: imperf: subj{np(str)} + obj{np(gen)} + {np(inst)} + {prepnp(za,acc)}
poszukiwać: imperf: subj{np(str)} + {prepnp(za,inst)}
poszybować: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
poszybować: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
pośliznąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
poślubić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
pośpieszyć: perf: subj,controller{np(str)} + controllee{infp(_)}
pośpieszyć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
pośpieszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pośpieszyć: perf: subj{np(str)} + {prepnp(do,gen); prepnp(ku,dat); prepnp(na,acc); xp(adl)} + {xp(perl)}
pośpieszyć się: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)}
pośpieszyć się: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
poświęcać: imperf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
poświęcać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen); prepncp(dla,gen,żeby)}
poświęcać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
poświęcać się: imperf: subj{np(str)} + {np(dat); ncp(dat,żeby)}
poświęcać się: imperf: subj{np(str)} + {prepnp(dla,gen)}
poświęcić: perf: subj{np(str)} + obj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
poświęcić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen); prepncp(dla,gen,żeby)}
poświęcić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
poświęcić się: perf: subj{np(str)} + {np(dat); ncp(dat,żeby)} + {np(inst)}
poświęcić się: perf: subj{np(str)} + {prepnp(dla,gen)}
potępiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {preplexnp(w,acc,sg,'czambuł',natr)}
potępiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
potępić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {preplexnp(w,acc,sg,'czambuł',natr)}
potępić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
potrafić: imperf: subj,controller{np(str)} + controllee{infp(_)}
potrafić: imperf: subj{np(str)} + {nonch}
potrącić: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
potrącić: perf: subj{np(str)} + obj{lexnp(str,sg,'struna',atr)} + {prepnp(u,gen)}
potrącić: perf: subj{np(str)} + obj{lexnp(str,sg,'struna',atr)} + {prepnp(w,loc)}
potrącić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
potrącić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
potrzebować: imperf: subj,controller{np(str)} + controllee{infp(_)}
potrzebować: imperf: subj{np(str)} + {np(part)} + {prepnp(dla,gen); prepnp(do,gen); prepnp(na,acc); cp(żeby); prepncp(do,gen,żeby)}
potwierdzać: imperf: subj{np(str)} + {cp(jakoby)}
potwierdzać: imperf: subj{np(str)} + {np(inst)} + {cp(int)}
potwierdzać: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
potwierdzać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
potwierdzać: imperf: subj{np(str)} + {or}
potwierdzać się: imperf: subj{cp(że)}
potwierdzać się: imperf: subj{np(str); ncp(str,że)}
potwierdzać się: imperf: subj{np(str)} + {prepnp(w,loc)}
potwierdzić: perf: subj{np(str)} + {cp(jakoby)}
potwierdzić: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,że)} + {np(inst); ncp(inst,że)}
potwierdzić: perf: subj{np(str)} + {or}
potwierdzić się: perf: subj{cp(że)}
potwierdzić się: perf: subj{np(str); ncp(str,że)}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {or}
pouczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {or}
pouczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
pouczyć się: perf: subj{np(str)} + {comprepnp(na temat)}
pouczyć się: perf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
pouczyć się: perf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
pouczyć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
pouczyć się: perf: subj{np(str)} + {prepnp(na,acc)}
pouczyć się: perf: subj{np(str)} + {prepnp(o,loc)}
powędrować: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
powędrować: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
powędrować: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
powędrować: perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
powędrować: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
powędrować: perf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
powędrować: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powiadać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {cp(że)}
powiadać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {cp(żeby)}
powiadać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {np(str)} + {or}
powiadać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(do,gen)} + {or}
powiadomić: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
powiadomić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
powiadomić: perf: subj{np(str)} + obj{np(str)} + {or}
powiadomić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
powierzać: imperf: subj{np(str)} + {np(dat)} + {refl}
powierzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
powierzać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)}
powierzać: imperf: subj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)} + {refl}
powierzyć: perf: subj{np(str)} + {np(dat)} + {refl}
powierzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powierzyć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)}
powierzyć: perf: subj{np(str)} + {preplexnp(w,acc,pl,'ręka',ratr)} + {refl}
powieść: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
powieść: perf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
powieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powieść: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
powieść się: perf: controller{np(dat)} + controllee{xp(mod)} + {prepnp(w,loc)}
powieść się: perf: subj,controllee{infp(perf)} + controller{np(dat)}
powieść się: perf: subj{np(str)} + {np(dat)}
powiększać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
powiększać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
powiększać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powiększyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
powiększyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
powiększyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
powinien: imperf: subj,controller{E} + controllee{infp(_)}
powitać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
powitać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
powitać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
powitać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
powołać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
powołać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
powołać się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
powracać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
powracać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
powracać: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
powrócić: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
powrócić: perf: subj{np(str)} + {np(inst)} + {xp(abl)}
powrócić: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
powrócić: perf: subj{np(str)} + {prepnp(w,loc)} + {xp(abl)}
powstać: perf: subj{np(str)} + {np(dat)}
powstać: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powstać: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
powstać: perf: subj{np(str)} + {prepnp(przeciw,dat)}
powstać: perf: subj{np(str)} + {prepnp(z,gen)}
powstawać: imperf: subj{np(str)} + {np(dat)}
powstawać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
powstawać: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
powstawać: imperf: subj{np(str)} + {prepnp(z,gen)}
powstawać: perf: subj{np(str)} + {prepnp(z,gen)}
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)}
powziąć: perf: subj{np(str)} + obj{np(str)}
pozazdrościć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
pozazdrościć: perf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,int); ncp(gen,że)}
pozbawiać: imperf: subj{np(str)} + {np(gen)} + {refl}
pozbawiać: imperf: subj{np(str)} + obj{np(str)} + {np(gen)}
pozbawić: perf: subj{np(str)} + {np(gen)} + {refl}
pozbawić: perf: subj{np(str)} + obj{np(str)} + {np(gen)}
pozbawić się: perf: subj{np(str)} + {np(gen)}
pozbierać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
pozbierać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
pozbierać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
pozbierać się: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)} + {advp(misc)}
pozbierać się: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,jak)} + {preplexnp(do,gen,sg,'kupa',natr)}
pozbierać się: perf: subj{np(str)} + {prepnp(w,acc)}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {or}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
pozdrawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
poznać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poznać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
poznać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
poznać: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
poznać: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
poznać się: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
poznać się: perf: subj{np(str)} + {prepnp(z,inst)}
poznawać: imperf: subj{np(str)} + {cp(jeśli)}
poznawać: imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
poznawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
poznawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
poznawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
poznawać: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
poznawać: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
poznawać się: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
poznawać się: imperf: subj{np(str)} + {prepnp(z,inst)}
pozostać: perf: controller{np(dat)} + controllee{infp(_)}
pozostać: perf: subj,controller{np(str)} + controllee{adjp(pred)}
pozostać: perf: subj,controller{np(str)} + controllee{np(inst)}
pozostać: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pozostać: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
pozostać: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
pozostać: perf: subj{np(str)} + {prepnp(bez,gen)}
pozostać: perf: subj{np(str)} + {prepnp(między,inst)}
pozostać: perf: subj{np(str)} + {prepnp(na,loc)}
pozostać: perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że)}
pozostać: perf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
pozostawać: imperf: subj,controllee{infp(_)} + controller{np(dat)}
pozostawać: imperf: subj,controller{np(str)} + controllee{adjp(pred)}
pozostawać: imperf: subj,controller{np(str)} + controllee{np(inst)}
pozostawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
pozostawać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
pozostawać: imperf: subj{np(str)} + {prepnp(bez,gen)}
pozostawać: imperf: subj{np(str)} + {prepnp(między,inst)}
pozostawać: imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że)}
pozostawać: imperf: subj{np(str)} + {prepnp(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)} + controllee{np(inst)}
pozostawiać: imperf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',atr)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
pozostawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
pozostawiać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozostawić: perf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',atr)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
pozostawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
pozować: imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)}
pozować: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
pozować: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
pozwalać: imperf: subj{np(str)} + controller{np(dat)} + controllee{prepnp(na,acc); cp(żeby); prepncp(na,acc,że); prepncp(na,acc,żeby); infp(_)}
pozwalać: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
pozwalać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
pozwalać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
pozwolić: perf: subj{np(str)} + controller{np(dat)} + controllee{prepnp(na,acc); cp(żeby); prepncp(na,acc,że); prepncp(na,acc,żeby); infp(_)}
pozwolić: perf: subj{np(str)} + {cp(że)}
pozwolić: perf: subj{np(str)} + {np(dat)} + {advp(misc)}
pozwolić: perf: subj{np(str)} + {np(gen)}
pozwolić: perf: subj{np(str)} + obj{np(str)}
pozwolić: perf: subj{np(str)} + {prepnp(do,gen)}
pozwolić: perf: subj{np(str)} + {prepnp(z,inst)}
pozyskać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pozyskać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozyskać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pozyskiwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
pozyskiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
pozyskiwać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
pożałować: perf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
pożałować: perf: subj{np(str)} + {np(gen); cp(że); ncp(gen,że)}
pożałować: perf: subj{np(str)} + {np(gen)} + {or}
pożądać: imperf: subj{np(str)} + obj{np(gen)}
pożegnać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
pożegnać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
pożerać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pożreć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
pożreć się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {prepnp(z,inst)}
pożyczać: imperf: subj{np(str)} + {np(part)} + {prepnp(od,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczać: imperf: subj{np(str)} + {np(part)} + {prepnp(z,gen)} + {lexnp(dat,_,'siebie',natr)}
pożyczać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)}
pożyczać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(od,gen)}
pożyczać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(u,gen)}
pożyczać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
pójść: perf: controller{np(dat)} + controllee{xp(mod)}
pójść: perf: {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr); preplexnp(w,acc,pl,'noga',natr)}
pójść: perf: {np(dat)} + {preplexnp(w,acc,pl,'pięta',natr)}
pójść: perf: {np(dat)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
pójść: perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
pójść: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
pójść: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
pójść: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ręka',natr)}
pójść: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'zdrowie',natr)}
pójść: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'noga',natr)}
pójść: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,acc,pl,'pięta',natr)}
pójść: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
pójść: perf: subj{np(str)} + {preplexnp(w,acc,pl,'ślad',ratr)}
pójść: perf: subj{np(str)} + {preplexnp(z,inst,pl,'torba',natr)}
pójść: perf: subj{np(str)} + {preplexnp(z,inst,sg,'dym',natr)}
pójść: perf: subj{np(str)} + {prepnp(do,gen)}
pójść: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pójść: perf: subj{np(str)} + {prepnp(po,acc)}
pójść: perf: subj{np(str)} + {prepnp(w,acc)}
pójść: perf: subj{np(str)} + {prepnp(za,acc)}
pójść: perf: subj{np(str)} + {prepnp(za,inst)}
pójść: perf: subj{np(str)} + {prepnp(za,inst)} + {preplexnp(w,acc,sg,'ogień',natr)}
pójść: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)} + {preplexnp(o,acc,sg,'zakład',natr)}
pójść: perf: subj{np(str)} + {prepnp(z,inst)} + {fixed('na udry')}
pójść: perf: subj{np(str)} + {prepnp(z,inst)} + {preplexnp(do,gen,sg,'łóżka',natr)}
pójść: perf: subj{np(str)} + {xp(adl)}
pójść: perf: subj{np(str)} + {xp(perl)}
pracować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
pracować: imperf: subj,controller{np(str)} + controllee{xp(mod)}
pracować: imperf: subj{np(str)} + {comprepnp(na rzecz)}
pracować: imperf: subj{np(str)} + {prepnp(dla,gen)}
pracować: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
pracować: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
pracować: imperf: subj{np(str)} + {prepnp(na,loc)}
pracować: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
pracować: imperf: subj{np(str)} + {prepnp(przy,loc)}
pracować: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
pragnąć: imperf: subj,controller{np(str)} + controllee{cp(żeby); infp(_)}
pragnąć: imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
praktykować: imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)}
praktykować: imperf: subj{np(str)} + {prepnp(u,gen)}
praktykować: imperf: subj{np(str)} + {prepnp(w,loc)}
praktykować: imperf: subj{np(str)} + {xp(locat)}
prasować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prawić: imperf: subj,controller{np(str)} + controllee{xp(mod)}
prawić: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
prawić: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
prawić: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
prawić: imperf: subj{np(str)} + {np(dat)} + {or}
prawić: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {nonch}
prawić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
precyzować: imperf: subj{np(str)} + obj{cp(int)}
precyzować: imperf: subj{np(str)} + obj{cp(że)}
precyzować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
precyzować: imperf: subj{np(str)} + {or}
precyzować się: imperf: subj{np(str)}
pretendować: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
produkować: imperf: subj{np(str)} + obj{np(str)}
produkować się: imperf: subj{np(str)} + {comprepnp(na temat)}
produkować się: imperf: subj{np(str)} + {or}
produkować się: imperf: subj{np(str)} + {xp(locat)}
prognozować: imperf: subj{np(str)} + obj{cp(int)}
prognozować: imperf: subj{np(str)} + obj{cp(że)}
prognozować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
programować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
programować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
programować: imperf: subj{np(str)} + {prepnp(na,inst)}
programować: imperf: subj{np(str)} + {prepnp(w,loc)}
projektować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
promieniować: imperf: subj{np(str)} + {np(inst)}
promieniować: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
promieniować: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
promieniować: imperf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
promieniować: imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
promieniować: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
promować: imperf: subj{np(str)} + {np(inst)} + {refl}
promować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
promować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
promować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
promować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
promować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
proponować: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
proponować: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
proponować: imperf: subj{np(str)} + {np(dat)} + {or}
proponować: imperf: subj{np(str)} + obj{np(str); cp(że); cp(żeby); ncp(str,żeby)} + {np(dat)}
proponować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
proponować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
prosić: imperf: {np(gen)}
prosić: imperf: subj,controller{np(str)} + controllee{infp(_)}
prosić: imperf: subj{np(str)} + obj{np(str)} + {or}
prosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
prosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
prosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepnp(za,acc); cp(żeby); prepncp(o,acc,żeby)}
prosić się: imperf: subj{np(str)} + {cp(żeby)}
prosić się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
protestować: imperf: subj{np(str)} + {cp(że)}
protestować: imperf: subj{np(str)} + {cp(żeby)}
protestować: imperf: subj{np(str)} + {or}
protestować: imperf: subj{np(str)} + {prepncp(przeciw,dat,jakoby)}
protestować: imperf: subj{np(str)} + {prepncp(przeciw,dat,żeby)}
protestować: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że)}
prowadzić: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
prowadzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
prowadzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
prowadzić: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
prowadzić: imperf: subj{np(str)} + {np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
prowadzić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
prowadzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
prowadzić: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'sznurek',natr)}
prowadzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
prowadzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
prowadzić: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
prowadzić: imperf: subj{np(str)} + {prepnp(przed,inst)}
prowadzić: imperf: subj{np(str)} + {prepnp(w,loc)}
prowadzić: imperf: subj{np(str)} + {prepnp(z,inst)}
prowadzić się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
prowokować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
prowokować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {cp(żeby)}
próbować: imperf: subj,controller{np(str)} + controllee{infp(_)}
próbować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'siła',batr)}
próbować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'szczęście',atr)}
próbować: imperf: subj{np(str)} + {cp(czy)}
próbować: imperf: subj{np(str)} + {np(gen)}
próbować: imperf: subj{np(str)} + obj{np(str)}
próbować: imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,pl,'siła',batr)}
próbować: imperf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,sg,'szczęście',atr)}
próbować: imperf: subj{np(str)} + {xp(locat)} + {lexnp(gen,pl,'siła',batr)}
próbować: imperf: subj{np(str)} + {xp(locat)} + {lexnp(gen,sg,'szczęście',atr)}
próbować się: imperf: subj{np(str)} + {prepnp(z,inst)}
przeanalizować: perf: subj{np(str)} + obj{cp(int)}
przeanalizować: perf: subj{np(str)} + obj{np(str); ncp(str,int)}
przebaczać: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
przebaczać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przebaczać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przebaczyć: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
przebaczyć: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przebaczyć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przebadać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przebadać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przebadać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przebadać się: perf: subj{np(str)} + {prepnp(na,acc)}
przebadać się: perf: subj{np(str)} + {prepnp(u,gen)}
przebadać się: perf: subj{np(str)} + {xp(locat)}
przebić: perf: subj{np(str)} + {np(inst)} + {refl}
przebić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(inst)}
przebić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przebić się: perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przebić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
przebić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przebiec: perf: subj,controller{np(str)} + controllee{xp(mod)}
przebiec: perf: subj{cp(że)} + {np(dat)} + {prepnp(przez,acc)}
przebiec: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
przebiec: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {or}
przebiec: perf: subj{np(str)} + {np(inst)} + {cp(int)}
przebiec: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przebiec: perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przebiec: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebiec: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebiec: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przebiec się: perf: subj{np(str)} + {prepnp(po,loc)}
przebiec się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przebiegać: imperf: subj,controller{np(str)} + controllee{xp(mod)}
przebiegać: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
przebiegać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przebiegać: imperf: subj{np(str)} + {np(str)} + {prepnp(po,loc)}
przebiegać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebiegać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebiegać: imperf: subj{np(str)} + {prepnp(przez,acc)}
przebiegać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przebiegać: imperf: subj{np(str)} + {xp(perl)}
przebiegać: perf: subj{np(str)} + obj{np(str)}
przebiegać się: imperf: subj{np(str)} + {prepnp(po,loc)}
przebierać: imperf: subj{np(str)} + {np(inst)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
przebierać: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'noga',natr)} + {preplexnp(z,gen,sg,'noga',natr)}
przebierać: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przebierać: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)} + {refl}
przebierać: imperf: subj{np(str)} + {prepnp(w,loc)}
przebierać: imperf: subj{np(str)} + {prepnp(wśród,gen)}
przebierać: imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
przebijać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen)}
przebijać: imperf: subj{np(str)} + {np(inst)} + {refl}
przebijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przebijać: imperf: subj{np(str)} + {prepnp(przez,acc)}
przebijać: imperf: subj{np(str)} + {prepnp(w,loc)}
przebijać: imperf: subj{np(str)} + {xp(abl)}
przebijać się: imperf: subj{np(str); ncp(str,że)} + {prepnp(w,loc)}
przebijać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przebijać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
przebijać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przebrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przebrać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
przebrać: perf: subj{np(str)} + {prepnp(do,gen)} + {refl}
przebrać: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)} + {refl}
przebrać: perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
przebrnąć: perf: subj{np(str)} + {np(str)}
przebrnąć: perf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int)}
przebrnąć: perf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
przebudować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przebudować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebudować się: perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować się: perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + {np(dat)} + {prepadjp(z,gen)}
przebudować się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przebudować się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przebudzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przebudzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przebudzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
przebudzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
przebudzić się: perf: subj{np(str)} + {prepnp(do,gen)}
przebudzić się: perf: subj{np(str)} + {prepnp(na,acc)}
przebudzić się: perf: subj{np(str)} + {prepnp(od,gen)}
przebudzić się: perf: subj{np(str)} + {prepnp(u,gen)}
przebudzić się: perf: subj{np(str)} + {prepnp(w,loc)}
przebudzić się: perf: subj{np(str)} + {prepnp(z,gen)}
przebywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przebywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)} + {xp(locat)}
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)}
przechwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przechwycić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przechylać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przechylać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przechylać się: imperf: subj{np(str)} + {prepnp(przez,acc)}
przechylać się: imperf: subj{np(str)} + {xp(adl)}
przechylić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przechylić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przechylić się: perf: subj{np(str)} + {prepnp(przez,acc)}
przechylić się: perf: subj{np(str)} + {xp(adl)}
przeciąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przeciąć się: perf: subj{np(str)} + {prepnp(z,inst)}
przeciągać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przeciągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przeciągać: imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przeciągać: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przeciągać: imperf: subj{np(str)} + {xp(perl)}
przeciągać się: imperf: subj{np(str)} + {xp(dur)}
przeciągnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
przeciągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przeciągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przeciągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przeciągnąć: perf: subj{np(str)} + {xp(perl)}
przeciągnąć się: perf: subj{np(str)} + {xp(dur)}
przecierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przecierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przecierać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {xp(locat)}
przecierać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
przecierać się: imperf: subj{np(str)} + {prepnp(po,loc)}
przecierać się: imperf: subj{np(str)} + {prepnp(z,gen)}
przecierać się: imperf: subj{np(str)} + {prepnp(z,inst)}
przecierać się: imperf: {xp(locat)}
przecinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
przecinać się: imperf: subj{np(str)} + {prepnp(z,inst)}
przeciskać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przeciskać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeciskać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przeciskać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przecisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przecisnąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przecisnąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przecisnąć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeciwdziałać: imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
przeciwstawiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przeciwstawiać się: imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
przeciwstawić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przeciwstawić się: perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst)}
przeczekać: perf: subj{np(str)} + {cp(aż)}
przeczekać: perf: subj{np(str)} + obj{np(str)}
przeczekać: perf: subj{np(str)} + {prepnp(do,gen)}
przeczesywać: imperf: subj{np(str)} + {np(inst)} + {refl}
przeczesywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeczesywać się: imperf: subj{np(str)} + {xp(perl)}
przeczyć: imperf: subj{np(str)} + {cp(jakoby)}
przeczyć: imperf: subj{np(str)} + {cp(że)}
przeczyć: imperf: subj{np(str)} + {ncp(dat,jakoby)}
przeczyć: imperf: subj{np(str)} + {ncp(dat,że)}
przeczyć: imperf: subj{np(str)} + {ncp(dat,żeby)}
przeczyć: imperf: subj{np(str)} + {np(dat)}
przeć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeć: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przeć: imperf: subj{np(str)} + {prepnp(ku,dat); prepncp(ku,dat,żeby)}
przeć: imperf: subj{np(str)} + {prepnp(na,acc)}
przeć: imperf: subj{np(str)} + {xp(adl)}
przedkładać: imperf: subj{np(str)} + {cp(że); cp(żeby)}
przedkładać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedkładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
przedkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
przedkładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,acc)}
przedostać się: perf: subj{cp(że)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostawać się: imperf: subj{cp(że)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedostawać się: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przedrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przedrzeć się: perf: subj{np(str)} + {prepnp(przez,acc)}
przedrzeć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przedsiębrać: imperf: subj{np(str)} + {infp(_)}
przedsiębrać: imperf: subj{np(str)} + obj{np(str)}
przedstawiać: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
przedstawiać: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
przedstawiać: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {refl}
przedstawiać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedstawiać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedstawiać się: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedstawiać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawiać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
przedstawiać się: imperf: subj{cp(że)} + {np(dat)}
przedstawiać się: imperf: subj{np(str)} + {lexnp(dat,pl,'oko',atr)}
przedstawiać się: imperf: subj{np(str)} + {np(dat)}
przedstawić: perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
przedstawić: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
przedstawić: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {refl}
przedstawić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
przedstawić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przedstawić się: perf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
przedstawić się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
przedstawić się: perf: subj,controller{np(str)} + controllee{xp(mod)}
przedstawić się: perf: subj{cp(że)} + {np(dat)}
przedstawić się: perf: subj{np(str)} + {lexnp(dat,pl,'oko',atr)}
przedstawić się: perf: subj{np(str)} + {np(dat)}
przedzierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przedzierać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przedzierać się: imperf: subj{np(str)} + {prepnp(przez,acc)}
przedzierać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przegłosować: perf: subj{np(str)} + {np(inst)} + {cp(int)}
przegłosować: perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
przegłosować: perf: subj{np(str)} + obj{cp(że)} + {np(inst)}
przegłosować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przegrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przeistaczać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeistaczać się: imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistaczać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeistoczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeistoczyć się: perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeistoczyć się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przejawiać: imperf: subj{np(str)} + obj{np(str)}
przejawiać się: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
przejawiać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
przejawiać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
przejawiać się: imperf: subj{np(str)} + {np(inst); prepnp(w,loc); ncp(inst,int); ncp(inst,że); ncp(inst,żeby); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przejąć: perf: subj{np(str)} + {np(inst)} + {np(str)}
przejąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
przejąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,acc)}
przejąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przejąć się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przejechać: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przejechać: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przejechać: perf: subj{np(str)} + {np(str)} + {xp(perl)}
przejechać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przejechać się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przejechać się: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
przejmować: imperf: subj{np(str)} + {np(inst)} + {np(str)}
przejmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
przejmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,acc)}
przejmować: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
przejmować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przejrzeć: perf: subj{np(str)} + {cp(int)} + {preplexnp(na,acc,pl,'oko',natr)}
przejrzeć: perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'oko',natr)}
przejrzeć: perf: subj{np(str)} + obj{np(str)}
przejrzeć się: perf: subj{np(str)} + {prepnp(do,gen)}
przejrzeć się: perf: subj{np(str)} + {prepnp(w,loc)}
przejść: perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: perf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: perf: subj{infp(_)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: perf: subj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,sg,'myśl',natr)}
przejść: perf: subj{np(str)} + {np(dat)} + {prepnp(koło,gen)}
przejść: perf: subj{np(str)} + {np(dat)} + {prepnp(między,inst)}
przejść: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
przejść: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przejść: perf: subj{np(str)} + {np(inst)}
przejść: perf: subj{np(str)} + {np(str)}
przejść: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)} + {prepnp(od,gen)}
przejść: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przejść: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przejść: perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(w,acc)}
przejść: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przejść się: perf: subj{np(str)} + {prepnp(do,gen)}
przejść się: perf: subj{np(str)} + {xp(adl)}
przejść się: perf: subj{np(str)} + {xp(perl)}
przekazać: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {cp(że); cp(żeby)}
przekazać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
przekazać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
przekazywać: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)} + {cp(że); cp(żeby)}
przekazywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(przez,acc)}
przekazywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
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)}
przekraczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przekreślać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przekreślić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przekroczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przekroczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przekształcać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + {prepadjp(z,gen)}
przekształcać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + {prepadjp(z,gen)}
przekształcać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekształcać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przekształcać się: imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {prepadjp(z,gen)}
przekształcać się: imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + {prepadjp(z,gen)}
przekształcać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przekształcać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przelać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przelać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
przelać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przelać się: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przelać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przelać się: perf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelatywać: imperf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: imperf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: imperf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelatywać: imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelatywać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelatywać: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
przelatywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przelatywać: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przelatywać: imperf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelatywać: imperf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: perf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: perf: subj{cp(int)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: perf: subj{cp(żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: perf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: perf: subj{cp(że)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: perf: subj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć: perf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelecieć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelecieć: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przelecieć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przelecieć: perf: subj{np(str)} + obj{np(str)} + {xp(perl)}
przelecieć: perf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'głowa',natr)}
przelecieć: perf: subj{or} + {np(dat)} + {preplexnp(przez,acc,_,'myśl',natr)}
przelecieć się: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelecieć się: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(perl)}
przelewać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przelewać się: imperf: {np(dat)}
przelewać się: imperf: {prepnp(u,gen)}
przelewać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przelewać się: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
przelewać się: imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
przelewać się: imperf: {xp(locat)}
przełknąć: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
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)}
przemieniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemieniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemieniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemieniać się: imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemieniać się: imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemieniać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemieniać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemienić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemienić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemienić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemienić się: perf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)}
przemienić się: perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przemienić się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przemienić się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przemieszczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przemieszczać się: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przemijać: perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
przemijać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przeminąć: perf: subj{np(str)} + controller{np(dat)} + controllee{xp(mod)}
przeminąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
przemóc: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przemóc: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,_,'siebie',natr)}
przemóc: perf: subj{np(str)} + {prepnp(w,loc)}
przemóc się: perf: subj{np(str)} + {cp(żeby)}
przemóc się: perf: subj{np(str)} + {prepnp(do,gen)}
przemóc się: perf: subj{np(str)} + {prepnp(w,loc)}
przemówić: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
przemówić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przemówić: perf: subj{np(str)} + {prepncp(za,inst,żeby)}
przemówić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,inst)}
przemówić: perf: subj{np(str)} + {prepnp(na,acc)}
przemówić: perf: subj{np(str)} + {prepnp(przeciw,dat)}
przemówić: perf: subj{np(str)} + {prepnp(przez,acc)}
przemówić: perf: subj{np(str)} + {prepnp(za,inst)}
przemówić się: perf: subj{np(str)} + {prepnp(z,inst)}
przemyśleć: perf: subj{np(str)} + {cp(int)}
przemyśleć: perf: subj{np(str)} + {cp(że)}
przemyśleć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
przenikać: imperf: subj{cp(że)} + {prepnp(do,gen)}
przenikać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przenikać: imperf: subj{np(str)} + {prepnp(do,gen)}
przenikać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przenikać się: imperf: subj{np(str)} + {prepnp(z,inst)}
przeniknąć: perf: subj{cp(że)} + {prepnp(do,gen)}
przeniknąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przeniknąć: perf: subj{np(str)} + {prepnp(do,gen)}
przeniknąć: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przeniknąć się: perf: subj{np(str)} + {prepnp(z,inst)}
przeoczyć: perf: subj{np(str)} + obj{cp(int)}
przeoczyć: perf: subj{np(str)} + obj{cp(jak)}
przeoczyć: perf: subj{np(str)} + obj{cp(że)}
przeoczyć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
przepadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepadać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przepadać: imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
przepadać: imperf: subj{np(str)} + {prepncp(za,inst,żeby2)}
przepadać: imperf: subj{np(str)} + {prepnp(na,loc)}
przepadać: imperf: subj{np(str)} + {prepnp(w,loc)}
przepadać: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,gdy); prepncp(za,inst,int); prepncp(za,inst,jak); prepncp(za,inst,kiedy); prepncp(za,inst,że)}
przepaść: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przepaść: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przepaść: perf: subj{np(str)} + {np(dat)} + {xp(temp)}
przepaść: perf: subj{np(str)} + {prepnp(na,loc)}
przepaść: perf: subj{np(str)} + {prepnp(w,loc)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przepisać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisać się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepisywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przepisywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
przepisywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepisywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przepisywać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przepisywać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przepłynąć: perf: subj{np(str)} + {np(dat)} + {xp(perl)}
przepłynąć: perf: subj{np(str)} + {np(inst)} + {prepnp(przez,acc)}
przepłynąć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przepłynąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przepłynąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przepłynąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przepłynąć: perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(przez,acc)}
przepłynąć się: perf: subj{np(str)} + {np(inst)} + {xp(perl)}
przepowiadać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przepowiadać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przepowiadać: imperf: subj{np(str)} + {np(dat)} + {or}
przepowiadać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przepowiedzieć: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przepowiedzieć: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przepowiedzieć: imperf: subj{np(str)} + {np(dat)} + {or}
przepowiedzieć: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przepracować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przepracować się: perf: subj{np(str)} + {np(inst)}
przepraszać: imperf: subj{np(str)} + {np(str)} + {or}
przepraszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); cp(że); prepncp(za,acc,że)}
przepraszać się: imperf: subj{np(str)} + {prepnp(z,inst)}
przeprosić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); cp(że); prepncp(za,acc,int); prepncp(za,acc,że)} + {or}
przeprosić się: perf: subj{np(str)} + {prepnp(z,inst)}
przerabiać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerabiać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerabiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerabiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przeradzać się: imperf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przeradzać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przerastać: imperf: subj{np(str); ncp(str,że)} + {np(str)}
przerastać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
przerastać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przerazić: perf: subj{cp(że)} + {np(str)}
przerazić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przerazić się: perf: subj{np(str)} + {cp(int)}
przerazić się: perf: subj{np(str)} + {cp(że)}
przerazić się: perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przerazić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przerażać: imperf: subj{cp(że)} + {np(str)}
przerażać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przerażać się: imperf: subj{np(str)} + {cp(int)}
przerażać się: imperf: subj{np(str)} + {cp(że)}
przerażać się: imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przerażać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przerobić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerobić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)} + {np(dat)}
przerobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przerodzić się: perf: subj,controller{np(str)} + controllee{prepadjp(w,acc)} + controllee{prepadjp(z,gen)}
przerodzić się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przerosnąć: perf: subj{np(str); ncp(str,że)} + {np(str)}
przerosnąć: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
przerosnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
przerwać: perf: subj{np(str)} + {np(dat)} + {or}
przerwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przerwać się: perf: subj{np(str)}
przerywać: imperf: subj{np(str)} + {np(dat)} + {or}
przerywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przerywać się: imperf: subj{np(str)}
przerzucać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(nad,inst)}
przerzucać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przerzucać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerzucać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przerzucać się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przerzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(nad,inst)}
przerzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przez,acc)}
przerzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
przerzucić się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przerzucić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przesadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesadzać: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
przesadzać: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
przesadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przesadzić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesadzić: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
przesadzić: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
przesądzić: perf: subj{np(str)} + {cp(żeby)}
przesądzić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przesądzić: perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)}
przesądzić: perf: subj{np(str)} + obj{cp(że)}
przesiadać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przesiadać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przesiadać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przesiadać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiadywać: imperf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
przesiadywać: imperf: subj{np(str)} + {prepnp(u,gen)} + {xp(dur)}
przesiadywać: imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przesiadywać: imperf: subj{np(str)} + {xp(dur)} + {xp(locat)} + {lexnp(inst,sg,'kamień',natr)}
przesiąść się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
przesiąść się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przesiąść się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
przesiąść się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przesiedzieć: perf: subj{np(str)} + {prepnp(przy,loc)} + {xp(dur)}
przesiedzieć: perf: subj{np(str)} + {prepnp(u,gen)} + {xp(dur)}
przesiedzieć: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przesłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przesłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(perl)}
przesłać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesłaniać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
przesłonić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
przesłuchać: perf: subj{np(str)} + obj{np(str)}
przesłuchiwać: imperf: subj{np(str)} + obj{np(str)}
przespać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przespać się: perf: subj{np(str)} + {prepnp(z,inst)}
przespać się: perf: subj{np(str)} + {xp(locat)}
przestać: perf: subj,controller{E} + controllee{infp(imperf)}
przestać: perf: subj{np(str)} + obj{np(str)}
przestawać: imperf: subj,controller{E} + controllee{infp(imperf)}
przestawać: imperf: subj{np(str)} + {prepnp(na,loc)}
przestawać: imperf: subj{np(str)} + {prepnp(z,inst)}
przestraszyć: perf: subj{cp(że)} + {np(str)}
przestraszyć: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przestraszyć się: perf: subj{np(str)} + {cp(int)}
przestraszyć się: perf: subj{np(str)} + {cp(że)}
przestraszyć się: perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)}
przestraszyć się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przestrzec: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przestrzec: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); cp(że); cp(żeby); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
przestrzec: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {or}
przestrzegać: imperf: subj{np(str)} + {np(gen); ncp(gen,że); ncp(gen,żeby)}
przestrzegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)}
przestrzegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst); cp(że); cp(żeby); prepncp(przed,inst,że); prepncp(przed,inst,żeby)}
przestrzegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {or}
przesuwać: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
przesuwać: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
przesuwać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przesuwać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
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{cp(że)} + {np(dat)} + {prepnp(w,loc)}
przeszkadzać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
przeszkadzać: imperf: subj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
przeszkadzać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przeszkodzić: perf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
przeszkodzić: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)} + {np(inst)}
przeszkodzić: perf: subj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
przeszkodzić: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
przeszukać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przeszukiwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
prześ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)}
przetłumaczyć: perf: subj{np(str)} + {np(dat)} + {or}
przetłumaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepadjp(na,acc)} + {prepadjp(z,gen)}
przetłumaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
przetłumaczyć: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)}
przetłumaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
przetrwać: perf: subj{np(str)} + obj{np(str)}
przetrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przetrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przetrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {xp(locat)}
przetrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
przetrzeć się: perf: subj{np(str)} + {prepnp(po,loc)}
przetrzeć się: perf: subj{np(str)} + {prepnp(z,gen)}
przetrzeć się: perf: subj{np(str)} + {prepnp(z,inst)}
przetrzeć się: perf: {xp(locat)}
przewidywać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
przewidywać: imperf: subj{np(str)} + {or}
przewidzieć: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
przewidzieć: perf: subj{np(str)} + {or}
przewieźć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przewieźć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(perl)}
przewijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przewijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przewijać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewijać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przewijać się: imperf: subj{np(str)} + {prepnp(w,loc)}
przewijać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewijać się: imperf: subj{np(str)} + {xp(locat)}
przewijać się: imperf: subj{np(str)} + {xp(perl)}
przewijać się: imperf: subj{or} + {np(dat)} + {prepnp(przez,acc)}
przewinąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
przewinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przewinąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewinąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
przewinąć się: perf: subj{np(str)} + {prepnp(w,loc)}
przewinąć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewinąć się: perf: subj{np(str)} + {xp(locat)}
przewinąć się: perf: subj{np(str)} + {xp(perl)}
przewinąć się: perf: subj{or} + {np(dat)} + {prepnp(przez,acc)}
przewodniczyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przewodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przewodzić: imperf: subj{np(str)} + obj{np(str)}
przewodzić: imperf: subj{np(str)} + {prepnp(nad,inst)}
przewozić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
przewozić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(perl)}
przewozić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
przewozić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
przewracać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przewracać: imperf: subj{np(str)} + {np(inst)}
przewracać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewracać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewracać się: imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
przewracać się: imperf: {np(dat)} + {xp(locat)}
przewracać się: imperf: subj{np(str)} + {np(dat)}
przewracać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przewracać się: imperf: subj{np(str)} + {preplexnp(w,loc,_,'grób',natr)}
przewracać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewrócić: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',natr)}
przewrócić: perf: subj{np(str)} + {np(inst)}
przewrócić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przewrócić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przewrócić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
przewrócić się: perf: {np(dat)} + {preplexnp(w,loc,pl,'głowa',natr)}
przewrócić się: perf: subj{np(str)} + {np(dat)}
przewrócić się: perf: subj{np(str)} + {preplexnp(w,loc,_,'grób',natr)}
przewrócić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
przewyższać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
przewyższać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
przewyższać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
przeziębić: perf: subj{np(str)} + obj{np(str)}
przeziębić się: perf: subj{np(str)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
przeznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
przeżyć: perf: subj,controller{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)} + controllee{xp(mod)}
przeżyć: perf: subj{np(str)} + {cp(że)}
przeżyć: perf: subj{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)}
przeżyć: perf: subj{np(str)} + {prepnp(na,loc)}
przeżyć: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
przeżyć się: perf: subj{np(str)}
przeżywać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(że)}
przeżywać: imperf: subj,controller{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + controllee{xp(mod)}
przeżywać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(z powodu)}
przeżywać: imperf: subj{np(str)} + obj{np(str)} + {xp(dur)}
przeżywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przeżywać: imperf: subj{np(str)} + {prepnp(na,loc)}
przeżywać: imperf: subj{np(str)} + {prepnp(z,inst)}
przeżywać się: imperf: subj{np(str)}
przodować: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(wśród,gen)}
przodować: imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
przybierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przybierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przybierać: imperf: subj{np(str)} + obj{refl} + {prepnp(w,acc)}
przybierać: imperf: subj{np(str)} + {prepnp(na,loc)}
przybliżać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przybliżać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przybliżać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przybliżać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przybliżać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżać się: imperf: subj{np(str)} + {xp(adl)}
przybliżyć: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżyć: perf: subj{np(str)} + {np(dat)} + {cp(int)}
przybliżyć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przybliżyć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przybliżyć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
przybliżyć się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przybliżyć się: perf: subj{np(str)} + {xp(adl)}
przybrać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przybrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
przybrać: perf: subj{np(str)} + {prepnp(na,loc)}
przybrać: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
przybyć: perf: {np(dat)} + {np(gen)}
przybyć: perf: {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybyć: perf: {np(gen)} + {xp(locat)}
przybyć: perf: subj{np(str)} + {np(dat)}
przybyć: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybyć: perf: subj{np(str)} + {prepnp(na,acc)}
przybyć: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przybyć: perf: subj{np(str)} + {xp(locat)}
przybywać: imperf: {np(dat)} + {np(gen)}
przybywać: imperf: {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybywać: imperf: {np(gen)} + {xp(locat)}
przybywać: imperf: subj{np(str)} + {np(dat)}
przybywać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'waga',natr)}
przybywać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
przybywać: imperf: subj{np(str)} + {xp(locat)}
przychodzić: imperf: subj,controllee{infp(_)} + controller{np(dat)}
przychodzić: imperf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przychodzić: imperf: subj,controller{np(str)} + controllee{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)}
przyczepiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przyczepiać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
przyczepiać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
przyczepiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
przyczepiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przyczepić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przyczepić się: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przyczepić się: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
przyczepić się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
przyczepić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
przyczepić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przyczyniać: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
przyczyniać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
przyczynić: perf: subj{np(str)} + {np(dat)} + {np(gen)} + {np(inst)}
przyczynić się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
przydać: perf: subj{np(str)} + {cp(że)}
przydać: perf: subj{np(str)} + obj{np(gen)} + {np(dat)}
przydać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydać się: perf: subj,controllee{infp(_)} + controller{np(dat)}
przydać się: perf: subj{cp(żeby)} + {np(dat)}
przydać się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydać się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przydać się: perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
przydać się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przydać się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przydać się: perf: subj{np(str)} + {np(dat)} + {xp(temp)}
przydawać: imperf: subj{np(str)} + {cp(że)}
przydawać: imperf: subj{np(str)} + obj{np(gen)} + {np(dat)}
przydawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydawać się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
przydawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przydawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
przydawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
przydawać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
przydawać się: imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
przydzielać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
przydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przydzielić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
przydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
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)}
przyjaźnić się: imperf: subj{np(str)} + {prepnp(z,inst)}
przyjąć: perf: subj,controller{np(str)} + controllee{infp(imperf)}
przyjąć: perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{prepadjp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{prepnp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
przyjąć: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(za,acc)}
przyjąć: perf: subj{np(str)} + obj{cp(że)} + {prepnp(za,inst)}
przyjąć: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
przyjąć: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {preplexnp(do,gen,sg,'wiadomość',atr)}
przyjąć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,_,'dach',batr)} + {fixed('z otwartymi ramionami')}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi ramionami')}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi rękami')}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
przyjąć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {xp(temp)}
przyjąć się: perf: {infp(imperf)}
przyjąć się: perf: subj{np(str)}
przyjmować: imperf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjmować: imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
przyjmować: imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
przyjmować: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(za,acc)}
przyjmować: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(za,inst)}
przyjmować: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
przyjmować: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {preplexnp(do,gen,sg,'wiadomości',atr)}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {fixed('z otwartymi ramionami')}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {fixed('z otwartymi rękami')}
przyjmować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {preplexnp(na,acc,sg,'wiara',natr)}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,_,'dach',batr)} + {fixed('z otwartymi ramionami')}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi ramionami')}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {fixed('z otwartymi rękami')}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
przyjmować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {xp(temp)}
przyjmować się: imperf: {infp(imperf)}
przyjmować się: imperf: subj{np(str)}
przyjrzeć się: perf: subj{np(str)} + {cp(jak)}
przyjrzeć się: perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyjrzeć się: perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przyjść: perf: controller{np(dat)} + controllee{infp(_)}
przyjść: perf: {np(dat)} + {prepncp(na,acc,że)}
przyjść: perf: {np(dat)} + {prepnp(na,acc)}
przyjść: perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
przyjść: perf: subj,controllee{infp(_)} + controller{np(dat)} + {preplexnp(na,acc,sg,'myśl',natr)}
przyjść: perf: subj,controller{np(str)} + controllee{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)}
przykazać: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
przykazać: perf: subj{np(str)} + {np(dat)} + {advp(pron)}
przykazać: perf: subj{np(str)} + {np(dat)} + {or}
przykazać: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
przykazać: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
przykazać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przykleić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przykleić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przykleić się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przykleić się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyklejać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
przyklejać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
przyklejać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyklejać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przykładać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przykładać: imperf: subj{np(str)} + obj{lexnp(str,sg,'waga',atr)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przykładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przykładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przykładać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
przykładać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przykładać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przykręcać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(na,acc)}
przykręcić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(na,acc)}
przykryć: perf: subj{np(str)} + {np(inst)} + {refl}
przykryć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przykuć: perf: subj{np(str); ncp(str,jak); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przykuć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przykuć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przykuwać: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
przykuwać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przykuwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przyłapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przyłapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
przyłapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
przyłapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
przyłapać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przyłapać: perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
przyłapać się: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
przyłączać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyłączać się: imperf: subj{np(str)} + {prepncp(do,gen,że)}
przyłączać się: imperf: subj{np(str)} + {prepnp(do,gen)}
przyłączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyłączyć się: perf: subj{np(str)} + {prepncp(do,gen,że)}
przyłączyć się: perf: subj{np(str)} + {prepnp(do,gen)}
przyłożyć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
przyłożyć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
przyłożyć: perf: subj{np(str)} + obj{lexnp(str,sg,'waga',atr)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyłożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przyłożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
przyłożyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przyłożyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przyłożyć się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
przymknąć: perf: subj{np(str)} + obj{lexnp(str,_,'oko',natr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przymknąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przymknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przymknąć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przymknąć się: perf: subj{np(str)} + {np(dat)}
przymocować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
przymykać: imperf: subj{np(str)} + obj{lexnp(str,_,'oko',natr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przymykać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przymykać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
przymykać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
przymykać się: imperf: subj{np(str)} + {np(dat)}
przynieść: perf: {np(str)} + {xp(adl)}
przynieść: perf: subj{lexnp(str,sg,'ślina',natr)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'język',natr)}
przynieść: perf: subj{np(str)} + {np(dat)} + {np(str)}
przynieść: perf: subj{np(str)} + {np(str)} + {xp(adl)}
przynieść: perf: subj{np(str)} + obj{np(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,controllee{infp(_)} + controller{np(dat)}
przypadać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'udział',natr)}
przypadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przypadać: imperf: subj{np(str)} + {prepnp(na,acc)}
przypadać: imperf: subj{np(str)} + {xp(temp)}
przypaść: perf: subj,controllee{np(str)} + controller{infp(_)}
przypaść: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'udział',natr)}
przypaść: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przypaść: perf: subj{np(str)} + {prepnp(na,acc)}
przypaść: perf: subj{np(str)} + {xp(temp)}
przypieczętować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
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}
przyprawiać: imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(o,acc)}
przyprawiać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)} + {prepnp(o,acc)}
przyprawiać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(o,acc)} + {refl}
przyprawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyprawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przyprawić: perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(o,acc)}
przyprawić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)} + {prepnp(o,acc)}
przyprawić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(o,acc)} + {refl}
przyprawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przyprawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypuszczać: imperf: subj{np(str)} + {advp(pron)}
przypuszczać: imperf: subj{np(str)} + {cp(int)}
przypuszczać: imperf: subj{np(str)} + {cp(że)}
przypuszczać: imperf: subj{np(str)} + {cp(żeby2)}
przypuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypuszczać: imperf: subj{np(str)} + {or}
przypuścić: perf: subj{np(str)} + {advp(pron)}
przypuścić: perf: subj{np(str)} + {cp(int)}
przypuścić: perf: subj{np(str)} + {cp(że)}
przypuścić: perf: subj{np(str)} + {cp(żeby2)}
przypuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przypuścić: perf: subj{np(str)} + {or}
przyrządzać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
przyrządzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
przyrzec: perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
przyrzec: perf: subj{np(str)} + {np(dat)} + {or}
przyrzec: perf: subj{np(str)} + obj{np(dat)} + {cp(że)}
przyrzec: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przyrzekać: perf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
przyrzekać: perf: subj{np(str)} + {np(dat)} + {or}
przyrzekać: perf: subj{np(str)} + obj{np(dat)} + {cp(że)}
przyrzekać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
przysiąc: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
przysiąc: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
przysiąść: perf: subj{np(str)} + {lexnp(gen,_,'fałd',natr)}
przysiąść: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
przysiąść: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przysiąść: perf: subj{np(str)} + {prepnp(do,gen)}
przysiąść: perf: subj{np(str)} + {xp(adl)}
przysiąść się: perf: subj{np(str)} + {prepnp(do,gen)}
przysłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przysłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
przysłuchiwać się: imperf: subj{np(str)} + {cp(int)}
przysłuchiwać się: imperf: subj{np(str)} + {cp(jak)}
przysłuchiwać się: imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,jak)}
przysługiwać: imperf: subj{np(str)} + {np(dat)}
przysłużyć się: perf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
przysłużyć się: perf: subj{np(str)} + {np(inst)} + {cp(że)}
przysłużyć się: perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
przystać: perf: {np(dat)} + {advp(pron)}
przystać: perf: subj,controllee{infp(_)} + controller{np(dat)}
przystać: perf: subj{cp(żeby)} + {np(dat)}
przystać: perf: subj{np(str)} + {np(dat)}
przystać: perf: subj{np(str)} + {prepnp(do,gen)}
przystać: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przystanąć: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
przystanąć: perf: subj{np(str)} + {xp(locat)}
przystawać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że)}
przystawać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
przystawać: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
przystawać: imperf: subj{np(str)} + {xp(locat)}
przystawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przystawiać się: imperf: subj{np(str)} + {prepnp(do,gen)}
przystawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
przystawić się: perf: subj{np(str)} + {prepnp(do,gen)}
przystąpić: perf: subj{np(str)} + {prepnp(do,gen)}
przystępować: imperf: subj{np(str)} + {prepnp(do,gen)}
przystosować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przystosować się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyswajać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przyswajać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyswajać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przyswoić: perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyswoić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyswoić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
przyświecać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
przyświecać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
przytrafiać się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
przytrafiać się: imperf: subj{cp(że)} + {np(dat)}
przytrafiać się: imperf: subj{np(str)} + {np(dat)}
przytrafić się: perf: subj,controllee{infp(_)} + controller{np(dat)}
przytrafić się: perf: subj{cp(że)} + {np(dat)}
przytrafić się: perf: subj{np(str)} + {np(dat)}
przytrzymać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {xp(locat)}
przytrzymać się: perf: subj{np(str)} + {np(gen)}
przytrzymywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)} + {xp(locat)}
przytrzymywać się: imperf: subj{np(str)} + {np(gen)}
przytulać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przytulać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytulać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
przytulać: imperf: subj{np(str)} + {prepnp(u,gen)} + {refl}
przytulić: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {refl}
przytulić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przytulić: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
przytulić: perf: subj{np(str)} + {prepnp(u,gen)} + {refl}
przywiązać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {refl}
przywiązać: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywiązać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)}
przywiązać się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywiązywać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)} + {refl}
przywiązywać: imperf: subj{np(str)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywiązywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(za,acc)}
przywiązywać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przywieść: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywieść: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywieść: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że)}
przywieść: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywitać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
przywitać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
przywitać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
przywodzić: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywodzić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(na,acc,sg,'myśl',natr)}
przywodzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że)}
przywodzić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywołać: perf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(jako,str)}
przywołać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przywołać: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)}
przywołać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przywołać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przywołać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywoływać: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(jako,str)}
przywoływać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przywoływać: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepnp(jako,str)}
przywoływać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przywoływać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
przywoływać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
przywracać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przywracać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przywracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przywracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przywrócić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
przywrócić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
przywrócić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
przywrócić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
przywyknąć: perf: subj,controller{np(str)} + controllee{infp(imperf)}
przywyknąć: perf: subj{np(str)} + {cp(że)}
przywyknąć: perf: subj{np(str)} + {cp(żeby)}
przywyknąć: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyznać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyznać: perf: subj{np(str)} + {or}
przyznać się: perf: subj{np(str)} + {np(dat)} + {cp(int)}
przyznać się: perf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznać się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby2)}
przyznać się: perf: subj{np(str)} + {or}
przyznawać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
przyznawać: imperf: subj{np(str)} + {or}
przyznawać się: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
przyznawać się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
przyznawać się: imperf: subj{np(str)} + {np(dat)} + {prepncp(do,gen,int)}
przyznawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że)}
przyznawać się: imperf: subj{np(str)} + {or}
przyzwyczaić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczaić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
przyzwyczaić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przyzwyczaić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyzwyczaić się: perf: subj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczaić się: perf: subj{np(str)} + {cp(że)}
przyzwyczaić się: perf: subj{np(str)} + {cp(żeby)}
przyzwyczaić się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyzwyczajać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczajać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
przyzwyczajać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
przyzwyczajać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
przyzwyczajać się: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
przyzwyczajać się: imperf: subj{np(str)} + {cp(że)}
przyzwyczajać się: imperf: subj{np(str)} + {cp(żeby)}
przyzwyczajać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
psuć: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
psuć się: imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
psuć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
pukać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
pukać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)} + {prepnp(z,inst)}
pukać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pukać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
pukać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
pukać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
pukać się: imperf: subj{np(str)} + {prepnp(z,inst)}
pulsować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
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)}
pytać: imperf: subj{np(str)} + obj{np(gen)} + {or}
pytać: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
pytać: imperf: subj{np(str)} + obj{np(str)} + {or}
pytać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
pytać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
pytać się: imperf: subj{np(str)} + {np(gen)} + {or}
pytać się: imperf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
rabować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)}
raczyć: imperf: subj,controller{np(str)} + controllee{infp(_)}
raczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
raczyć się: imperf: subj{np(str)} + {np(inst)}
radzić: imperf: subj{np(str)} + {comprepnp(na temat)}
radzić: imperf: subj{np(str)} + controller{np(dat)} + controllee{cp(żeby); infp(_)}
radzić: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
radzić: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
radzić: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
radzić: imperf: subj{np(str)} + {np(dat)} + {or}
radzić: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
radzić: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int)}
radzić: imperf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(dat,_,'siebie',natr)}
radzić się: imperf: subj{np(str)} + {np(gen)} + {cp(int)}
radzić się: imperf: subj{np(str)} + {np(gen)} + {prepnp(w,loc)}
radzić się: imperf: subj{np(str)} + {prepnp(u,gen)}
ranić: imperf: subj{cp(gdy)} + {np(str)}
ranić: imperf: subj{cp(jak)} + {np(str)}
ranić: imperf: subj{cp(jeśli)} + {np(str)}
ranić: imperf: subj{cp(kiedy)} + {np(str)}
ranić: imperf: subj{cp(że)} + {np(str)}
ranić: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,acc)}
ranić: _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
ranić: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ranić się: _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
ranić się: _: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
ratować: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(od,gen)}
ratować: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
ratować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(przed,inst)}
ratować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ratować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ratować się: imperf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
ratować się: imperf: subj{np(str)} + {prepnp(od,gen)}
ratować się: imperf: subj{np(str)} + {prepnp(przed,inst)}
ratować się: imperf: subj{np(str)} + {prepnp(w,loc)}
ratować się: imperf: subj{np(str)} + {prepnp(z,gen)}
ratyfikować: _: subj{np(str)} + obj{np(str)} + {np(inst)}
razić: imperf: subj{cp(gdy)} + {np(str)}
razić: imperf: subj{cp(jak)} + {np(str)}
razić: imperf: subj{cp(jeśli)} + {np(str)}
razić: imperf: subj{cp(kiedy)} + {np(str)}
razić: imperf: subj{cp(że)} + {np(str)}
razić: imperf: subj{np(str); ncp(str,gdy); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
razić: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {np(str)}
razić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
razić: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
razić: _: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rąbnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rąbnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
rąbnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
rąbnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rąbnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rąbnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rąbnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rąbnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rąbnąć: perf: subj{np(str)} + {or}
rąbnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rąbnąć: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rąbnąć: perf: subj{np(str)} + {xp(adl)}
rąbnąć: perf: subj{np(str)} + {xp(locat)}
rąbnąć: perf: {xp(locat)}
rąbnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rąbnąć się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rąbnąć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
reagować: imperf: subj{np(str)} + controller{prepnp(na,acc); prepncp(na,acc,jak); prepncp(na,acc,że)} + controllee{xp(mod)}
reagować: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,jak); prepncp(na,acc,że)}
reagować: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int)}
reagować: imperf: subj{np(str)} + {prepnp(z,inst)}
realizować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
realizować się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
realizować się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
recytować: imperf: subj{np(str)} + obj{np(str)}
recytować: imperf: subj{np(str)} + {or}
regulować: imperf: subj{np(str)} + obj{lexnp(str,pl,'rachunek',atr)} + {prepnp(z,inst)}
regulować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
regulować się: imperf: subj{np(str)}
rekomendować: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
rekomendować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
rekomendować: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rekomendować: imperf: subj{np(str)} + {np(dat)} + {infp(_)}
rekomendować: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {refl}
rekomendować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {refl}
rekomendować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
rekomendować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
rekomendować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rekomendować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rekomendować: imperf: subj{np(str)} + {or}
rekomendować: imperf: subj{np(str)} + {or} + {refl}
rekrutować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(spośród,gen)}
rekrutować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
rekrutować się: imperf: subj{np(str)} + {prepnp(do,gen)}
rekrutować się: imperf: subj{np(str)} + {prepnp(spośród,gen)}
rekrutować się: imperf: subj{np(str)} + {prepnp(z,gen)}
rekrutować się: imperf: subj{np(str)} + {xp(abl)}
remontować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
remontować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
reprezentować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
respektować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
rezerwować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rezerwować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
rezerwować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rezygnować: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
robić: imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
robić: imperf: subj{np(str)} + {cp(że)} + {advp(misc)}
robić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
robić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {advp(misc)}
robić: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
robić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
robić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
robić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
robić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
robić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
robić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
robić: imperf: subj{np(str)} + {prepnp(przy,loc)}
robić: imperf: subj{np(str)} + {prepnp(w,acc)}
robić: imperf: subj{np(str)} + {prepnp(z,gen)} + {nonch} + {lexnp(dat,_,'siebie',natr)}
robić się: imperf: {np(dat)} + {advp(misc)}
robić się: imperf: {prepnp(z,inst)} + {advp(misc)}
robić się: imperf: subj,controller{np(str)} + controllee{adjp(pred)}
robić się: imperf: subj,controller{np(str)} + controllee{np(inst)}
robić się: imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)}
robić się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
robić się: imperf: subj{np(str)} + {prepnp(z,gen)}
robić się: imperf: {xp(locat)} + {advp(misc)}
rodzić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
rodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rodzić się: imperf: subj,controller{np(str)} + controllee{adjp(inst)}
rodzić się: imperf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
rodzić się: imperf: subj{np(str)} + {np(dat)}
rodzić się: imperf: subj{np(str)} + {preplexnp(na,loc,sg,'kamień',natr)}
rodzić się: imperf: subj{np(str)} + {prepnp(u,gen)}
rodzić się: imperf: subj{np(str)} + {prepnp(w,loc)}
rodzić się: imperf: subj{np(str)} + {prepnp(z,gen)}
roić: imperf: subj{np(str)} + {cp(że)}
roić: imperf: subj{np(str)} + {np(str)}
roić: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby)}
roić się: imperf: {np(dat)} + {prepnp(od,gen)} + {preplexnp(w,loc,_,'głowa',natr)}
roić się: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
roić się: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
roić się: imperf: subj{E} + {prepnp(od,gen)} + {xp(locat)}
roić się: imperf: subj{np(str)} + {np(dat)} + {preplexnp(po,loc,_,'głowa',natr)}
roić się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
roić się: imperf: subj{np(str)} + {prepnp(od,gen)}
rosnąć: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
rosnąć: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rosnąć: imperf: subj{np(str)} + {prepnp(w,acc)}
rozbić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozbić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozbić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbić się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
rozbić się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
rozbić się: perf: subj{np(str)} + {np(inst)}
rozbić się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozbić się: perf: subj{np(str)} + {xp(locat)}
rozbierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozbierać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)}
rozbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozbierać: imperf: subj{np(str)} + {preplexnp(do,gen,sg,'rosół',natr)} + {refl}
rozbierać: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
rozbijać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozbijać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
rozbijać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
rozbijać się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(o,acc)}
rozbijać się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {prepnp(w,acc)}
rozbijać się: perf: subj{np(str)} + {np(inst)}
rozbijać się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
rozbijać się: perf: subj{np(str)} + {xp(locat)}
rozciągać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozciągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozciągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rozciągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozciągać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozciągać się: imperf: subj{np(str)} + {prepnp(na,acc)}
rozciągać się: imperf: subj{np(str)} + {prepnp(w,loc)}
rozciągać się: imperf: subj{np(str)} + {xp(abl)}
rozciągać się: imperf: subj{np(str)} + {xp(locat)}
rozciągnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rozciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozciągnąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozciągnąć się: perf: subj{np(str)} + {prepnp(na,acc)}
rozciągnąć się: perf: subj{np(str)} + {prepnp(w,loc)}
rozciągnąć się: perf: subj{np(str)} + {xp(abl)}
rozciągnąć się: perf: subj{np(str)} + {xp(locat)}
rozczarować: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
rozczarować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozczarować się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
rozczarować się: perf: subj{np(str)} + {prepnp(do,gen)}
rozdać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ręka',atr)}
rozdać: perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdać: perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,sg,'ręka',atr)}
rozdawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdzielić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozdzielić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rozdzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
rozdzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(między,inst)}
rozdzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rozdzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozdzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozdzielić się: perf: subj{np(str)} + {prepnp(na,acc)}
rozdzielić się: perf: subj{np(str)} + {prepnp(z,inst)}
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}
rozejrzeć się: perf: subj{np(str)} + {cp(int)} + {xp(adl)}
rozejrzeć się: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozejrzeć się: perf: subj{np(str)} + {prepnp(po,loc); xp(locat)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
rozejrzeć się: perf: subj{np(str)} + {prepnp(w,loc)}
roześmiać się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {cp(że)}
roześmiać się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
roześmiać się: perf: subj{np(str)} + {np(inst)}
roześmiać się: perf: subj{np(str)} + {prepnp(z,gen)}
rozglądać się: imperf: subj{np(str)} + {cp(int)} + {xp(adl)}
rozglądać się: imperf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozglądać się: imperf: subj{np(str)} + {prepnp(po,loc); xp(locat)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
rozglądać się: imperf: subj{np(str)} + {prepnp(w,loc)}
rozgniewać: perf: subj{cp(że); ncp(str,że)} + {np(str)}
rozgniewać: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
rozgniewać się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
rozgniewać się: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
rozgniewać się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
rozgniewać się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
rozgromić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozgromić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozgrzać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozgrzać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozgrzać się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rozgrzać się: perf: subj{np(str)} + {np(inst)}
rozjaśniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjaśniać się: imperf: {np(dat)} + {xp(locat)}
rozjaśniać się: imperf: subj{np(str)} + {np(dat)}
rozjaśnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozjaśnić się: perf: {np(dat)} + {xp(locat)}
rozjaśnić się: perf: subj{np(str)} + {np(dat)}
rozkazać: perf: subj,controller{np(str)} + controllee{np(str); infp(_)} + {np(dat)}
rozkazać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
rozkazać: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rozkazać: perf: subj{np(str)} + {np(dat)} + {or}
rozkazywać: imperf: subj,controller{np(str)} + controllee{infp(_)} + {np(dat)}
rozkazywać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
rozkazywać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rozkazywać: imperf: subj{np(str)} + {np(dat)} + {np(str)}
rozkazywać: imperf: subj{np(str)} + {np(dat)} + {or}
rozkręcać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozkręcać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozkręcić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
rozkręcić się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozkwitać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozkwitnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
rozlać: perf: subj{np(str)} + obj{np(str)} + {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)}
rozlec się: perf: subj{np(str)} + {xp(abl); xp(locat)} + {or}
rozlec się: perf: subj{or} + {xp(abl)}
rozlec się: perf: subj{or} + {xp(locat)}
rozlegać się: imperf: subj{np(str)} + {xp(abl); xp(locat)} + {or}
rozlegać się: imperf: subj{or} + {xp(abl)}
rozlegać się: imperf: subj{or} + {xp(locat)}
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)}
rozluźnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozluźnić się: perf: subj{np(str)} + {np(dat)}
rozładować: perf: subj{ncp(str,że)} + obj{np(str)}
rozładować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
rozładować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozładować się: perf: subj{np(str)} + {np(dat)}
rozładowywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
rozładowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rozładowywać się: imperf: subj{np(str)} + {np(dat)}
rozłączać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozłączać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozłączać: imperf: subj{np(str)} + {prepnp(z,inst)} + {refl}
rozłączać się: imperf: subj{np(str)} + {np(dat)}
rozłączać się: imperf: subj{np(str)} + {prepnp(z,inst)}
rozłączyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozłączyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozłączyć: perf: subj{np(str)} + {prepnp(z,inst)} + {refl}
rozłączyć się: perf: subj{np(str)} + {np(dat)}
rozłączyć się: perf: subj{np(str)} + {prepnp(z,inst)}
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ślać: imperf: subj{np(str)} + {cp(int)}
rozmyślać: imperf: subj{np(str)} + {cp(że)}
rozmyślać: imperf: subj{np(str)} + {or}
rozmyślać: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozmyślać: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozmyślać się: imperf: subj{np(str)}
rozmyślać się: imperf: subj{np(str)} + {prepnp(z,gen)}
rozmyślić się: perf: subj{np(str)}
rozmyślić się: perf: subj{np(str)} + {prepnp(z,gen)}
rozpaczać: imperf: subj{np(str)} + {comprepnp(z powodu)}
rozpaczać: imperf: subj{np(str)} + {cp(int)}
rozpaczać: imperf: subj{np(str)} + {cp(że)}
rozpaczać: imperf: subj{np(str)} + {or}
rozpaczać: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
rozpaczać: imperf: subj{np(str)} + {prepnp(po,loc)}
rozpadać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpadać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpadać się: perf: {E}
rozpadać się: perf: subj{np(str)}
rozpakować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpakować się: perf: subj{np(str)}
rozpakowywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rozpakowywać się: imperf: subj{np(str)}
rozpaść się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rozpaść się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rozpędzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpędzić się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
rozpłynąć się: perf: subj{np(str)} + {prepnp(nad,inst)}
rozpłynąć się: perf: subj{np(str)} + {prepnp(w,loc)}
rozpłynąć się: perf: subj{np(str)} + {xp(locat)}
rozpływać się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,jak); prepncp(nad,inst,że)}
rozpływać się: imperf: subj{np(str)} + {prepnp(w,loc)}
rozpływać się: imperf: subj{np(str)} + {xp(locat)}
rozpocząć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozpocząć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpocząć: perf: subj{np(str)} + obj{np(str)} + {or}
rozpocząć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
rozpocząć się: perf: subj,controller{np(str)} + controllee{xp(mod)}
rozpocząć się: perf: subj{np(str)} + {np(inst)}
rozpocząć się: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
rozpocząć się: perf: subj{np(str)} + {xp(locat)}
rozpocząć się: perf: subj{np(str)} + {xp(temp)}
rozpoczynać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
rozpoczynać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpoczynać: imperf: subj{np(str)} + obj{np(str)} + {or}
rozpoczynać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
rozpoczynać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
rozpoczynać się: imperf: subj{np(str)} + {np(inst)}
rozpoczynać się: imperf: subj{np(str)} + {or}
rozpoczynać się: imperf: subj{np(str)} + {prepnp(od,gen)}
rozpoczynać się: imperf: subj{np(str)} + {xp(locat)}
rozpoczynać się: imperf: subj{np(str)} + {xp(temp)}
rozpowszechniać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpowszechniać się: imperf: subj{np(str)} + {xp(locat)}
rozpowszechnić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozpowszechnić się: perf: subj{np(str)} + {xp(locat)}
rozpoznać: perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
rozpoznać: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
rozpoznać: perf: subj{np(str)} + {cp(int); ncp(str,int)}
rozpoznać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
rozpoznać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
rozpoznać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozpoznać: perf: subj{np(str)} + {or}
rozpoznać: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(int)}
rozpoznać: perf: subj{np(str)} + {prepnp(po,loc)} + {cp(że)}
rozpoznać się: perf: subj{np(str)} + {prepnp(w,loc)}
rozproszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozproszyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozproszyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rozproszyć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozproszyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozproszyć się: perf: subj{np(str)} + {prepnp(na,acc)}
rozproszyć się: perf: subj{np(str)} + {prepnp(po,loc)}
rozproszyć się: perf: subj{np(str)} + {xp(adl)}
rozproszyć się: perf: subj{np(str)} + {xp(locat)}
rozprzestrzeniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzeniać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozprzestrzeniać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozprzestrzeniać się: imperf: subj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzeniać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozprzestrzeniać się: imperf: subj{np(str)} + {xp(locat)}
rozprzestrzenić: perf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzenić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozprzestrzenić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozprzestrzenić się: perf: subj{np(str)} + {prepnp(wśród,gen)}
rozprzestrzenić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
rozprzestrzenić się: perf: subj{np(str)} + {xp(locat)}
rozpuszczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozpuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozpuszczać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozpuszczać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozpuścić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozpuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozpuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozpuścić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozpuścić się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
rozrastać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozrastać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozrastać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozrastać się: imperf: subj{np(str)} + {xp(adl)}
rozrosnąć się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozrosnąć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
rozrosnąć się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozrosnąć się: perf: subj{np(str)} + {xp(adl)}
rozróżniać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozróżniać: imperf: subj{np(str)} + {prepnp(między,inst)}
rozróżniać: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozróżniać: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozróżniać: imperf: subj{np(str)} + {prepnp(pomiędzy,inst)}
rozróżnić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
rozróżnić: perf: subj{np(str)} + {prepnp(między,inst)}
rozróżnić: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
rozróżnić: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
rozróżnić: perf: subj{np(str)} + {prepnp(pomiędzy,inst)}
rozstać się: perf: subj{np(str)} + {prepnp(z,inst)}
rozstawać się: imperf: subj{np(str)} + {prepnp(z,inst)}
rozstawiać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
rozstawiać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
rozstawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozstawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozstawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozstawiać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozstawiać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozstawić: perf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
rozstawić: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
rozstawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
rozstawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozstawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozstawić się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
rozstawić się: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
rozstrzelać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
rozstrzelać się: perf: subj{np(str)}
rozstrzeliwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
rozsypać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozsypać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozsypać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozsypać się: perf: subj{np(str)} + {prepnp(na,acc)}
rozsypać się: perf: subj{np(str)} + {prepnp(w,acc)}
rozsypać się: perf: subj{np(str)} + {xp(adl)}
rozsypać się: perf: subj{np(str)} + {xp(locat)}
rozsypywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozsypywać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rozsypywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
rozsypywać się: imperf: subj{np(str)} + {prepnp(na,acc)}
rozsypywać się: imperf: subj{np(str)} + {prepnp(w,acc)}
rozsypywać się: imperf: subj{np(str)} + {xp(adl)}
rozsypywać się: imperf: subj{np(str)} + {xp(locat)}
rozszerzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozszerzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozszerzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
rozszerzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozszerzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozszerzać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
rozszerzać się: imperf: subj{np(str)} + {prepnp(do,gen)}
rozszerzać się: imperf: subj{np(str)} + {prepnp(ku,dat)}
rozszerzać się: imperf: subj{np(str)} + {prepnp(na,acc)}
rozszerzać się: imperf: subj{np(str)} + {prepnp(o,acc)}
rozszerzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
rozszerzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rozszerzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
rozszerzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rozszerzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
rozszerzyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
rozszerzyć się: perf: subj{np(str)} + {np(inst)}
rozszerzyć się: perf: subj{np(str)} + {prepnp(do,gen)}
rozszerzyć się: perf: subj{np(str)} + {prepnp(ku,dat)}
rozszerzyć się: perf: subj{np(str)} + {prepnp(na,acc)}
rozszerzyć się: perf: subj{np(str)} + {prepnp(o,acc)}
rozumieć: imperf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
rozumieć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
rozumieć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
rozumieć: imperf: subj{np(str)} + obj{np(str)}
rozumieć: imperf: subj{np(str)} + {prepadjp(po,postp)}
rozumieć: imperf: subj{np(str)} + {prepnp(przez,acc)} + {cp(że)}
rozumieć: imperf: subj{np(str)} + {prepnp(przez,acc)} + {ncp(str,że)}
rozumieć: imperf: subj{np(str)} + {prepnp(przez,acc)} + {nonch}
rozumieć się: imperf: subj{np(str)} + {prepnp(na,loc)}
rozumieć się: imperf: subj{np(str)} + {prepnp(z,inst)}
rozumować: imperf: subj,controller{np(str)} + controllee{xp(mod)}
rozumować: imperf: subj{np(str)} + {cp(że)}
rozumować: imperf: subj{np(str)} + {np(inst)}
rozumować: imperf: subj{np(str)} + {or}
rozwiać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
rozwiać się: perf: subj{np(str)} + {np(dat)}
rozwiać się: perf: subj{np(str)} + {xp(adl)}
rozwiać się: perf: subj{np(str)} + {xp(locat)}
rozwieść: perf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
rozwieść się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozwieść się: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozwieść się: perf: subj{np(str)} + {prepnp(z,inst)}
rozwijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
rozwijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
rozwijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozwijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozwijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozwijać się: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
rozwijać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
rozwijać się: imperf: subj{np(str)} + {prepnp(u,gen)}
rozwijać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozwijać się: imperf: subj{np(str)} + {prepnp(w,loc)}
rozwinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
rozwinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
rozwinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rozwinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rozwinąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rozwinąć się: perf: subj{np(str)} + {np(dat)} + {advp(misc)}
rozwinąć się: perf: subj{np(str)} + {prepnp(przed,inst)}
rozwinąć się: perf: subj{np(str)} + {prepnp(u,gen)}
rozwinąć się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
rozwinąć się: perf: subj{np(str)} + {prepnp(w,loc)}
rozwodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
rozwodzić się: imperf: subj{np(str)} + {comprepnp(na temat)}
rozwodzić się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
rozwodzić się: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
rozwodzić się: imperf: subj{np(str)} + {prepnp(z,inst)}
równać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
równać się: imperf: subj,controller{infp(_)} + controllee{infp(_)}
równać się: imperf: subj,controller{infp(_)} + controllee{np(nom)}
równać się: imperf: subj,controller{np(str)} + controllee{np(nom)}
równać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
równać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
różnić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(od,gen)} + {advp(misc)}
różnić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)} + {prepnp(z,inst)} + {advp(misc)}
różnić: imperf: subj{np(str)} + {np(str)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
różnić się: imperf: subj{np(str)} + {comprepnp(co do)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
różnić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); preplexnp(pod,inst,_,'wzgląd',atr)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
różnić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); preplexnp(pod,inst,_,'wzgląd',atr)} + {prepnp(od,gen)} + {advp(misc)}
różnić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); preplexnp(pod,inst,_,'wzgląd',atr)} + {prepnp(z,inst)} + {advp(misc)}
różnić się: imperf: subj{np(str)} + {prepnp(od,gen)} + {comprepnp(co do)} + {advp(misc)}
różnić się: imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)} + {advp(misc)}
różnić się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)} + {advp(misc)} + {preplexnp(między,inst,_,'siebie',natr)}
różnić się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)} + {prepnp(z,inst)} + {advp(misc)}
różnić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
różnić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)} + {advp(misc)}
rujnować: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {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)}
rwać: imperf: {np(str)} + {xp(locat)}
rwać: imperf: subj{np(str)} + obj{lexnp(str,pl,'włos',natr)} + {lexnp(dat,_,'siebie',natr)} + {preplexnp(z,gen,sg,'głowa',natr)}
rwać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rwać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rwać: imperf: subj{np(str)} + {xp(adl)}
rwać się: imperf: subj{np(str)} + {cp(żeby)}
rwać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rwać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rwać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
rwać się: imperf: subj{np(str)} + {xp(adl)}
rysować: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
rysować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
rysować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
rysować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rysować się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
rysować się: imperf: subj{np(str)} + {xp(locat)}
rywalizować: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {preplexnp(między,inst,_,'siebie',natr)}
rywalizować: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
rywalizować: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
ryzykować: imperf: subj{np(str)} + {cp(że)}
ryzykować: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
ryzykować: imperf: subj{np(str)} + {np(str); ncp(str,że)}
rządzić: imperf: subj{np(str)} + obj{np(inst)}
rządzić: imperf: subj{np(str)} + {xp(locat)}
rządzić się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
rządzić się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
rzec: perf: subj{np(str)} + {np(dat)} + {cp(int)}
rzec: perf: subj{np(str)} + {np(dat)} + {cp(że)}
rzec: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
rzec: perf: subj{np(str)} + {np(dat)} + {np(str)}
rzec: perf: subj{np(str)} + {np(dat)} + {or}
rzec: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
rzeźbić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
rzucać: imperf: {np(inst)} + {advp(misc)}
rzucać: imperf: {np(inst)} + {prepnp(po,loc)}
rzucać: imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
rzucać: imperf: {np(str)} + {prepnp(po,loc)}
rzucać: imperf: {np(str)} + {xp(abl)} + {xp(adl)}
rzucać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {preplexnp(na,acc,pl,'kolano',natr)}
rzucać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {cp(że)}
rzucać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
rzucać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucać: imperf: subj{np(str)} + obj{lexnp(str,sg,'światło',atr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucać: imperf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
rzucać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
rzucać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
rzucać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
rzucać: imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
rzucać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rzucać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
rzucać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
rzucać się: imperf: {np(dat)} + {prepnp(na,acc)}
rzucać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
rzucać się: imperf: subj{cp(int)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: imperf: subj{cp(jak)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: imperf: subj{cp(żeby)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: imperf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(w,acc)}
rzucać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rzucać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rzucać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
rzucać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rzucić: perf: {np(inst)} + {advp(misc)}
rzucić: perf: {np(inst)} + {xp(adl)}
rzucić: perf: {np(str)} + {xp(adl)}
rzucić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {preplexnp(na,acc,pl,'kolano',natr)}
rzucić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {cp(że)}
rzucić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
rzucić: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucić: perf: subj{np(str)} + obj{lexnp(str,sg,'światło',atr)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
rzucić: perf: subj{np(str)} + obj{np(inst)} + {np(dat)} + {prepnp(w,acc)}
rzucić: perf: subj{np(str)} + obj{np(inst)} + {prepnp(na,acc)}
rzucić: perf: subj{np(str)} + obj{np(inst)} + {prepnp(o,acc)}
rzucić: perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
rzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
rzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
rzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzucić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rzucić: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucić: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
rzucić: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
rzucić się: perf: {np(dat)} + {prepnp(na,acc)}
rzucić się: perf: subj,controller{np(str)} + controllee{infp(_)}
rzucić się: perf: subj{cp(int)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: perf: subj{cp(jak)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: perf: subj{cp(żeby2)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: perf: subj{cp(że)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {prepnp(w,acc)}
rzucić się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
rzucić się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
rzucić się: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
rzucić się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
rzucić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
rzutować: imperf: subj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{xp(mod)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
rzutować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
rzutować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rżnąć: imperf: {np(str)} + {xp(locat)}
rżnąć: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
rżnąć: imperf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(od,gen,sg,'ucho',natr)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
rżnąć: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
rżnąć: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
rżnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
rżnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rżnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
rżnąć: _: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
rżnąć: _: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
rżnąć się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
satysfakcjonować: imperf: subj{cp(że)} + {np(str)}
satysfakcjonować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
sądzić: imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
sądzić: imperf: subj{np(str)} + {cp(że)}
sądzić: imperf: subj{np(str)} + {cp(żeby2)}
sądzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
sądzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sądzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(według,gen)}
sądzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
sądzić: imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
sądzić: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
sądzić się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(z,inst)}
sąsiadować: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
sąsiadować: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
sąsiadować: imperf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)}
schodzić: imperf: {comprepnp(na temat)}
schodzić: imperf: {np(dat)} + {prepnp(na,loc)}
schodzić: imperf: {prepnp(na,acc)}
schodzić: imperf: subj{np(str)} + {comprepnp(na temat)}
schodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
schodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
schodzić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
schodzić: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
schodzić: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
schodzić: perf: subj{np(str)} + obj{np(str)}
schodzić się: imperf: subj{np(str)} + {prepnp(do,gen)}
schodzić się: imperf: subj{np(str)} + {prepnp(z,inst)}
schodzić się: imperf: subj{np(str)} + {xp(adl)}
schodzić się: imperf: subj{np(str)} + {xp(locat)}
schodzić się: perf: subj{np(str)}
schować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(adl)}
schować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {xp(locat)}
schować: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
schować: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {xp(locat)}
schować: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)} + {refl}
schować: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
schować się: perf: subj{np(str)} + {prepnp(przy,loc)}
schować się: perf: subj{np(str)} + {prepnp(z,inst)}
schylać: imperf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
schylać się: imperf: subj{np(str)} + {prepnp(po,acc)}
schylać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
schylić: perf: subj{np(str)} + {np(str)} + {prepnp(przed,inst)}
schylić się: perf: subj{np(str)} + {prepnp(po,acc)}
schylić się: perf: subj{np(str)} + {prepnp(przed,inst)}
serwować: imperf: subj{np(str)} + {np(inst)}
serwować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
sędziować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
sędziować: imperf: subj{np(str)} + {prepnp(w,loc)}
sędziować: imperf: subj{np(str)} + {xp(locat)}
sfinansować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sfinansować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
sformułować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
sformułować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
siać: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
siać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
siadać: imperf: subj{np(str)} + {prepnp(do,gen)}
siadać: imperf: subj{np(str)} + {xp(adl)}
siadać: imperf: subj{np(str)} + {xp(locat)}
siąść: perf: subj{np(str)} + {prepnp(do,gen)}
siąść: perf: subj{np(str)} + {xp(adl)}
siąść: perf: subj{np(str)} + {xp(locat)}
siedzieć: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
siedzieć: imperf: subj{np(str)} + {lexnp(inst,sg,'kamień',natr)}
siedzieć: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,loc,sg,'kark',natr)}
siedzieć: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
siedzieć: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
siedzieć: imperf: subj{np(str)} + {prepnp(nad,inst)}
siedzieć: imperf: subj{np(str)} + {prepnp(na,loc)}
siedzieć: imperf: subj{np(str)} + {prepnp(przy,loc)}
siedzieć: imperf: subj{np(str)} + {prepnp(w,loc)}
siedzieć: imperf: subj{np(str)} + {prepnp(za,acc)} + {xp(dur)}
silić się: imperf: subj,controller{np(str)} + controllee{infp(_)}
silić się: imperf: subj{np(str)} + {cp(żeby)}
silić się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
siodłać: imperf: subj{np(str)} + obj{np(str)}
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(int)}
skarżyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
skarżyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {cp(że)}
skarżyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,że)}
skarżyć: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int)}
skarżyć: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
skarżyć: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
skarżyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(int); cp(że)}
skarżyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {or}
skarżyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(int); cp(że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {or}
skarżyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
skarżyć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
skarżyć się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {or}
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ć: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
składać się: imperf: {np(dat)} + {cp(że)} + {advp(misc)}
składać się: imperf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
składać się: imperf: subj{np(str)} + {prepnp(do,gen)}
składać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
składać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(po,acc)}
składać się: imperf: subj{np(str)} + {prepnp(z,gen)}
składować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skomentować: perf: subj{np(str)} + {cp(że)}
skomentować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {or}
skonać: perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
skonać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
skonać: perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
skoncentrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
skoncentrować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skoncentrować się: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że); prepncp(na,loc,żeby)}
skoncentrować się: perf: subj{np(str)} + {prepnp(wokół,gen); prepncp(wokół,gen,int); prepncp(wokół,gen,że); prepncp(wokół,gen,żeby)}
skonstruować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
skontaktować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
skontaktować się: perf: subj{np(str)} + {prepnp(przez,acc)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
skontrolować: perf: subj{np(str)} + {cp(int)} + {refl}
skontrolować: perf: subj{np(str)} + {cp(że)}
skontrolować: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
skontrolować: perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
skończyć: perf: subj,controller{np(str)} + controllee{infp(imperf)}
skończyć: perf: subj,controller{np(str)} + controllee{xp(mod)}
skończyć: perf: subj{np(str)} + obj{np(str)}
skończyć: perf: subj{np(str)} + {prepnp(z,inst)}
skończyć się: perf: {prepnp(na,loc); prepncp(na,loc,że)}
skończyć się: perf: subj{np(str)} + {np(inst)}
skończyć się: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
skończyć się: perf: subj{np(str)} + {xp(temp)}
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)}
skreślić: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
skreślić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
skreślić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
skró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ć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skupić się: perf: subj{np(str)} + {prepnp(na,loc); prepnp(nad,inst); prepncp(na,loc,int); prepncp(na,loc,żeby)}
skupić się: perf: subj{np(str)} + {prepnp(w,acc)}
skupić się: perf: subj{np(str)} + {prepnp(wokół,gen)}
skupić się: perf: subj{np(str)} + {xp(locat)}
skupować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
skupować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
skutkować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
skutkować: imperf: subj{np(str)} + {np(inst)} + {prepnp(dla,gen)}
słuchać: imperf: subj{np(str)} + {cp(int)}
słuchać: imperf: subj{np(str)} + {cp(że)}
słuchać: imperf: subj{np(str)} + {np(gen); prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)}
słuchać: imperf: subj{np(str)} + {np(inst)} + {cp(jak)}
słuchać: imperf: subj{np(str)} + {np(str)}
słuchać: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)} + {np(inst)}
słuchać się: imperf: subj{np(str)} + {np(gen)}
służyć: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
służyć: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {np(dat)}
służyć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
służyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(dla,gen)}
służyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
służyć: imperf: subj{np(str)} + {prepnp(pod,inst)}
służyć: imperf: subj{np(str)} + {prepnp(u,gen)}
służyć: imperf: subj{np(str)} + {prepnp(w,loc)}
słychać: imperf: {cp(int)} + {xp(locat)}
słychać: imperf: {cp(jak)} + {xp(locat)}
słychać: imperf: {cp(że); cp(żeby2)} + {xp(locat)}
słychać: imperf: {ncp(str,int)} + {xp(locat)}
słychać: imperf: {ncp(str,jak)} + {xp(locat)}
słychać: imperf: {np(str); ncp(str,że); or} + {xp(locat)}
słychać: imperf: {prepncp(o,loc,int); prepncp(o,loc,jak)} + {xp(locat)}
słychać: imperf: {prepncp(o,loc,że)} + {xp(locat)}
słychać: imperf: {prepnp(o,loc)} + {xp(locat)}
słynąć: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
słynąć: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
słynąć: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
słynąć: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
słyszeć: imperf: subj{np(str)} + obj{cp(jakoby)}
słyszeć: imperf: subj{np(str)} + obj{cp(jak)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: imperf: subj{np(str)} + obj{cp(żeby2)}
słyszeć: imperf: subj{np(str)} + obj{cp(że)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: imperf: subj{np(str)} + obj{np(str); cp(int); cp(jak); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(inst)}
słyszeć: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'ucho',batr)}
słyszeć: imperf: subj{np(str)} + obj{np(str); prepnp(o,loc); cp(int); cp(jak); cp(że); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że)} + {prepnp(od,gen)}
słyszeć: imperf: subj{np(str)} + {prepncp(o,loc,jakoby)}
słyszeć: imperf: subj{np(str)} + {prepncp(o,loc,żeby)}
słyszeć: imperf: subj{np(str)} + {prepnp(od,gen)} + {or}
słyszeć: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że); prepncp(o,loc,żeby2)} + {nonch}
słyszeć: imperf: subj{np(str)} + {refl}
smakować: imperf: subj,controller{np(str)} + controllee{xp(mod)}
smakować: imperf: subj{np(str)} + {np(dat)}
smakować: imperf: subj{np(str)} + obj{np(str)}
smarować: imperf: subj{np(str)} + {np(inst)} + {refl}
smarować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
smarować: imperf: subj{np(str)} + {xp(adl)}
snuć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
snuć się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
snuć się: imperf: subj{np(str)} + {np(dat)} + {xp(perl)}
snuć się: imperf: subj{np(str)} + {prepnp(za,inst)}
snuć się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
solić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
solić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
solidaryzować się: imperf: subj{np(str)} + {prepnp(z,inst)}
spacerować: imperf: subj{np(str)} + {xp(perl)}
spać: imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
spać: imperf: subj{np(str)} + {prepnp(nad,inst)}
spać: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(u,gen)}
spać: imperf: subj{np(str)} + {prepnp(z,inst)}
spać: imperf: subj{np(str)} + {xp(locat)}
spadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spadać: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
spadać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
spadać: imperf: subj{np(str)} + {prepnp(na,loc)}
spadać: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
spalać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
spalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
spalać: imperf: subj{np(str)} + {preplexnp(na,loc,sg,'panewka',natr)}
spalać się: imperf: subj{np(str)} + {advp(misc)}
spalać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spalać się: imperf: subj{np(str)} + {prepnp(w,loc)}
spalać się: imperf: subj{np(str)} + {prepnp(z,gen)}
spalić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
spalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
spalić: perf: subj{np(str)} + {preplexnp(na,loc,sg,'panewka',natr)}
spalić się: perf: subj{np(str)} + {advp(misc)}
spalić się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spalić się: perf: subj{np(str)} + {prepnp(w,loc)}
spalić się: perf: subj{np(str)} + {prepnp(z,gen)}
sparaliżować: perf: subj{np(str); ncp(str,że)} + obj{np(str)}
sparaliżować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sparaliżować: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
spaść: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spaść: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spaść: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
spaść: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
spaść: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
spaść: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
spaść: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
spaść się: perf: subj{np(str)} + {np(inst)}
spaść się: perf: subj{np(str)} + {prepnp(na,loc)}
specjalizować się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że); prepncp(w,loc,żeby)}
spekulować: imperf: subj{np(str)} + {comprepnp(na temat)}
spekulować: imperf: subj{np(str)} + {cp(int)}
spekulować: imperf: subj{np(str)} + {cp(że)}
spekulować: imperf: subj{np(str)} + {np(inst)}
spekulować: imperf: subj{np(str)} + {or}
spekulować: imperf: subj{np(str)} + {prepnp(na,loc)}
spekulować: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
spełniać: imperf: subj{np(str)} + obj{np(str)}
spełniać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,nom)}
spełniać się: imperf: subj{np(str)} + {prepnp(w,loc)}
spełnić: perf: subj{np(str)} + obj{np(str)}
spełnić się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
spełnić się: perf: subj{np(str)} + {prepnp(w,loc)}
spędzać: imperf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'oko',natr)}
spędzać: imperf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'powieka',natr)}
spędzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
spędzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,inst)}
spędzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
spędzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
spędzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
spędzać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spędzać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
spędzić: perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'oko',natr)}
spędzić: perf: subj{np(str)} + {np(dat)} + {lexnp(str,sg,'sen',natr)} + {preplexnp(z,gen,pl,'powieka',natr)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {advp(misc)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,inst)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {xp(locat)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spędzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
spierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
spierać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(z,inst)}
spierać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
spierać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
spierać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
spieszyć: imperf: subj,controller{np(str)} + controllee{infp(_)}
spieszyć: imperf: subj{np(str)} + {np(dat)} + {np(str)}
spieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
spieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
spieszyć: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(ku,dat); prepnp(na,acc); xp(adl)} + {xp(perl)}
spieszyć: perf: subj{np(str)} + obj{np(str)}
spieszyć: perf: subj{np(str)} + {refl}
spieszyć się: imperf: {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
spieszyć się: imperf: subj,controller{np(str)} + controllee{infp(_)}
spieszyć się: imperf: subj{np(str)} + {np(dat)} + {np(str)}
spieszyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spieszyć się: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
spieszyć się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
spisać: perf: subj{np(str)} + obj{cp(int)}
spisać: perf: subj{np(str)} + obj{cp(że)}
spisać: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
spisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
spisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
spisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
spisać: perf: subj{np(str)} + obj{np(str)} + {or}
spisać: perf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
spisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
spisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
spisać się: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
spisywać: imperf: subj{np(str)} + obj{cp(int)}
spisywać: imperf: subj{np(str)} + obj{cp(że)}
spisywać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
spisywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
spisywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
spisywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
spisywać: imperf: subj{np(str)} + obj{np(str)} + {or}
spisywać: imperf: subj{np(str)} + obj{np(str)} + {prepadjp(po,postp)}
spisywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
spisywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
spisywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
spłacać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spłacić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
spłonąć: perf: subj{np(str)} + {np(dat)} + {np(inst)}
spocić się: perf: subj{np(str)} + {np(dat)}
spocząć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
spocząć: perf: subj{np(str)} + {prepnp(na,loc)}
spocząć: perf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
spocząć: perf: subj{np(str)} + {xp(dur)}
spoczywać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
spoczywać: imperf: subj{np(str)} + {prepnp(na,loc)}
spoczywać: imperf: subj{np(str)} + {prepnp(w,loc)} + {xp(locat)}
spodobać się: perf: {np(dat)} + {xp(locat)}
spodobać się: perf: subj,controllee{infp(_)} + controller{np(dat)}
spodobać się: perf: subj{cp(gdy)} + {np(dat)}
spodobać się: perf: subj{cp(jak)} + {np(dat)}
spodobać się: perf: subj{cp(kiedy)} + {np(dat)}
spodobać się: perf: subj{cp(że)} + {np(dat)}
spodobać się: perf: subj{np(str); ncp(str,jak); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
spodziewać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
spodziewać się: imperf: subj{np(str)} + {np(gen); cp(że); cp(żeby); ncp(gen,że); ncp(gen,żeby)} + {prepnp(po,loc)}
spodziewać się: imperf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)}
spoglądać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spoglądać: imperf: subj{np(str)} + {cp(int)}
spoglądać: imperf: subj{np(str)} + {cp(że)}
spoglądać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spoglądać: imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
spoglądać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
spoglądać: imperf: subj{np(str)} + {prepnp(po,loc)}
spoglądać się: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spoglądać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spoglądać się: imperf: subj{np(str)} + {prepnp(na,acc)}
spojrzeć: perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spojrzeć: perf: subj{np(str)} + {cp(int)}
spojrzeć: perf: subj{np(str)} + {cp(że)}
spojrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spojrzeć: perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(inst,sg,'wilk',natr)}
spojrzeć: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
spojrzeć: perf: subj{np(str)} + {prepnp(po,loc)}
spojrzeć: perf: subj{np(str)} + {xp(adl)}
spojrzeć się: perf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{xp(mod)}
spojrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
spojrzeć się: perf: subj{np(str)} + {prepnp(na,acc)}
sporządzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
sporządzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
sposobić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
sposobić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
sposobić się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
sposobić się: imperf: subj{np(str)} + {prepnp(na,acc)}
spostrzec: perf: subj{np(str)} + {cp(gdy)}
spostrzec: perf: subj{np(str)} + {cp(int)}
spostrzec: perf: subj{np(str)} + {cp(jak)}
spostrzec: perf: subj{np(str)} + {cp(kiedy)}
spostrzec: perf: subj{np(str)} + {cp(że)}
spostrzec: perf: subj{np(str)} + obj{np(str); ncp(str,że)}
spostrzec się: perf: subj{np(str)} + {cp(gdy)}
spostrzec się: perf: subj{np(str)} + {cp(int)}
spostrzec się: perf: subj{np(str)} + {cp(jak)}
spostrzec się: perf: subj{np(str)} + {cp(kiedy)}
spostrzec się: perf: subj{np(str)} + {cp(że)}
spotkać: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
spotkać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spotkać się: perf: subj{np(str)} + {prepnp(z,inst)}
spotykać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
spotykać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
spotykać się: imperf: subj{np(str)} + {prepnp(z,inst)}
spowiadać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowiadać się: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
spowiadać się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
spowiadać się: imperf: subj{np(str)} + {np(dat)} + {or}
spowiadać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowiadać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
spowiadać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
spowiadać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
spowiadać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowiadać się: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
spowodować: perf: subj{np(str)} + {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(str)} + {prepnp(do,gen); prepnp(na,acc)}
spóźnić się: perf: subj{np(str)} + {np(str)} + {prepnp(z,inst)}
spóźnić się: perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(o,acc)}
spóźnić się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
sprawdzać: imperf: subj{np(str)} + obj{cp(że)}
sprawdzać: imperf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
sprawdzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprawdzać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
sprawdzać się: imperf: subj{cp(że)}
sprawdzać się: imperf: subj{ncp(str,że)}
sprawdzać się: imperf: subj{np(str)} + {np(dat)}
sprawdzać się: imperf: subj{np(str)} + {prepnp(w,loc)}
sprawdzać się: imperf: subj{np(str)} + {xp(locat)}
sprawdzić: perf: subj{np(str)} + obj{cp(że)}
sprawdzić: perf: subj{np(str)} + obj{np(str); cp(int); ncp(str,int)}
sprawdzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sprawdzić się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
sprawdzić się: perf: subj{cp(że)}
sprawdzić się: perf: subj{ncp(str,że)}
sprawdzić się: perf: subj{np(str)} + {np(dat)}
sprawdzić się: perf: subj{np(str)} + {prepnp(w,loc)}
sprawdzić się: perf: subj{np(str)} + {xp(locat)}
sprawiać: imperf: subj{np(str)} + {cp(żeby)}
sprawiać: imperf: subj{np(str); cp(że); ncp(str,że)} + obj{np(str)} + {np(dat)} + {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)} + controllee{xp(mod)}
sprawić: perf: subj{np(str)} + {cp(żeby)}
sprawić: perf: subj{np(str); cp(że); ncp(str,że)} + obj{np(str)} + {np(dat)} + {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)} + controllee{xp(mod)}
sprawować: imperf: subj{np(str)} + obj{np(str)}
sprawować się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
sprecyzować: perf: subj{np(str)} + obj{cp(int)}
sprecyzować: perf: subj{np(str)} + obj{cp(że)}
sprecyzować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
sprecyzować: perf: subj{np(str)} + {or}
sprecyzować się: perf: subj{np(str)}
sprostać: perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)}
sprostać: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprowokować: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
sprowokować: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {cp(żeby)}
spróbować: perf: subj,controller{np(str)} + controllee{infp(_)}
spróbować: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,pl,'siła',batr)}
spróbować: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(gen,sg,'szczęście',atr)}
spróbować: perf: subj{np(str)} + {cp(czy)}
spróbować: perf: subj{np(str)} + {np(gen)}
spróbować: perf: subj{np(str)} + {np(str)}
spróbować: perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,pl,'siła',batr)}
spróbować: perf: subj{np(str)} + {prepnp(w,loc)} + {lexnp(gen,sg,'szczęście',atr)}
spróbować: perf: subj{np(str)} + {xp(locat)} + {lexnp(gen,pl,'siła',batr)}
spróbować: perf: subj{np(str)} + {xp(locat)} + {lexnp(gen,sg,'szczęście',atr)}
spróbować się: perf: subj{np(str)} + {prepnp(z,inst)}
sprywatyzować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
sprywatyzować się: perf: subj{np(str)}
sprzątać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
sprzątać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sprzątać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sprzątnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
sprzątnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
sprzątnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
sprzątnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
sprzeciwiać się: imperf: subj{np(str)} + {cp(że)}
sprzeciwiać się: imperf: subj{np(str)} + {cp(żeby)}
sprzeciwiać się: imperf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)} + {or}
sprzeciwiać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprzeciwić się: perf: subj{np(str)} + {cp(że)}
sprzeciwić się: perf: subj{np(str)} + {cp(żeby)}
sprzeciwić się: perf: subj{np(str)} + {np(dat); ncp(dat,int); ncp(dat,że); ncp(dat,żeby)} + {or}
sprzeciwić się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sprzyjać: imperf: subj{np(str)} + {np(dat); ncp(dat,że); ncp(dat,żeby)}
sprzyjać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
spuszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spuszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
spuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
spuszczać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spuszczać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuszczać się: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
spuszczać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
spuszczać się: imperf: subj{np(str)} + {prepnp(na,acc)}
spuszczać się: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
spuszczać się: imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
spuszczać się: imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
spuszczać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
spuścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
spuścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
spuścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
spuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
spuścić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
spuścić się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
spuścić się: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
spuścić się: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
spuścić się: perf: subj{np(str)} + {prepnp(na,acc)}
spuścić się: perf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(po,loc)}
spuścić się: perf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
spuścić się: perf: subj{np(str)} + {prepnp(po,loc)} + {xp(abl)} + {xp(adl)}
spuścić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
spychać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
spychać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
spytać: perf: subj{np(str)} + obj{np(gen)} + {or}
spytać: perf: subj{np(str)} + obj{np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
spytać: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
spytać: perf: subj{np(str)} + obj{np(str)} + {or}
spytać: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
spytać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
spytać się: perf: subj{np(str)} + {np(gen)} + {or}
spytać się: perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); cp(int); prepncp(o,acc,int)}
ssać: imperf: {np(str)} + {prepnp(od,gen)} + {xp(locat)}
ssać: imperf: {np(str)} + {prepnp(z,gen)} + {xp(locat)}
ssać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
ssać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
staczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
staczać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
staczać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
stanowić: imperf: subj{cp(że)} + {np(str)}
stanowić: imperf: subj{ncp(str,że)} + {prepnp(o,loc)}
stanowić: imperf: subj{np(str)} + {cp(że)}
stanowić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
stanowić: imperf: subj{np(str)} + obj{np(str)}
stanowić: imperf: subj{np(str)} + {prepncp(o,loc,int)}
stanowić: imperf: subj{np(str)} + {prepncp(o,loc,że)}
stanowić: imperf: subj{np(str)} + {prepncp(o,loc,żeby2)}
stanowić: imperf: subj{np(str)} + {prepnp(o,loc)}
starać się: imperf: subj,controller{np(str)} + controllee{prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby); infp(_)}
starczyć: perf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
starczyć: perf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
starczyć: perf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
starczyć: perf: {np(gen)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
starczyć: perf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: perf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
starczyć: perf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
starczyć: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
starczyć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)}
starczyć: perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(do,gen)}
starczyć: perf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(na,acc)}
startować: imperf: subj{np(str)} + {prepnp(do,gen)}
startować: imperf: subj{np(str)} + {prepnp(w,loc)}
startować: imperf: subj{np(str)} + {xp(abl)}
stawiać: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'czoło',natr)}
stawiać: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)} + {cp(że)}
stawiać: imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {prepnp(za,acc)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,sg,'pręgierz',ratr)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'pręgierz',ratr)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
stawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
stawiać: imperf: subj{np(str)} + {prepadjp(na,loc)}
stawiać: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
stawiać: imperf: subj{np(str)} + {prepnp(za,acc)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
stawiać: imperf: subj{np(str)} + {prepnp(za,acc)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
stawiać: imperf: subj{np(str)} + {prepnp(za,acc)} + {infp(_)} + {lexnp(dat,_,'siebie',natr)}
stawiać się: imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'kant',natr)}
stawiać się: imperf: subj{np(str)} + {np(dat)} + {lexnp(inst,sg,'okoń',natr)}
stawiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(inst,sg,'sztorc',natr)}
stawiać się: imperf: subj{np(str)} + {prepnp(u,gen)}
stawiać się: imperf: subj{np(str)} + {prepnp(wobec,gen)}
stawiać się: imperf: subj{np(str)} + {xp(adl)}
stawiać się: imperf: subj{np(str)} + {xp(locat)}
stemplować: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
stemplować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
sterczeć: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
sterczeć: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
sterować: imperf: subj{np(str)} + obj{np(inst)} + {np(inst)}
sterować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
stłuc: perf: subj{np(str)} + obj{np(str)} + {fixed('na kwaśne jabłko')}
stłuc: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
stłuc: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'miazga',atr)}
stłuc się: perf: subj{np(str)} + {np(inst)}
stłuc się: perf: subj{np(str)} + {prepnp(o,acc)}
stoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
stoczyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
stoczyć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
stosować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
stosować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
stosować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
stosować się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
stracić: perf: subj{np(str)} + {lexnp(str,sg,'grunt',natr)} + {preplexnp(pod,inst,pl,'noga',natr)}
stracić: perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,pl,'oko',natr)}
stracić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
stracić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
stracić: perf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',ratr)}
stracić: perf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,sg,'serce',natr)}
stracić: perf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,sg,'serce',natr)}
stracić: perf: subj{np(str)} + {prepnp(z,gen)} + {nonch}
strajkować: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że)}
straszyć: imperf: subj{np(str)} + {cp(że)} + {refl}
straszyć: imperf: subj{np(str)} + {np(inst)} + {refl}
straszyć: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
straszyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst); cp(że)}
straszyć: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
straszyć: imperf: subj{np(str)} + {or}
strącać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strącać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
strącić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
strącić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
streszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
streszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
streszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
streszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
streszczać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
streszczać się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
streszczać się: imperf: subj{np(str)} + {prepnp(z,inst)}
streścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
streścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
streścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
streścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
streścić się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że)}
streścić się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
stronić: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
strzec: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(od,gen); prepncp(od,gen,żeby)}
strzec: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(przed,inst)}
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)}
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)}
stymulować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
sugerować: imperf: subj{np(str)} + {np(dat)} + {or}
sugerować: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
sugerować: imperf: subj{np(str)} + obj{cp(jakoby)} + {np(dat)} + {np(inst)}
sugerować: imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {np(inst)}
sugerować: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
sugerować: imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
sugerować się: imperf: subj{np(str)} + {cp(że)}
sugerować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
sunąć: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
sunąć: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
sunąć: imperf: subj{np(str)} + {np(inst)} + {xp(perl)}
sunąć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
sunąć: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
sunąć: imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(abl)} + {xp(adl)}
sunąć: imperf: subj{np(str)} + {prepnp(na,loc)} + {xp(perl)}
sunąć: imperf: subj{np(str)} + {prepnp(za,inst)}
sunąć się: imperf: subj{np(str)} + {prepnp(po,loc)}
sunąć się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
sunąć się: imperf: subj{np(str)} + {xp(perl)}
suszyć: imperf: {np(str)}
suszyć: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {lexnp(str,sg,'głowa',natr)}
suszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)} + {lexnp(str,sg,'głowa',natr)}
suszyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
suszyć się: imperf: subj{np(str)} + {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)}
sygnalizować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
sygnalizować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
sygnalizować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,loc); prepncp(o,loc,że)}
sygnalizować: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
sygnalizować: imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
symbolizować: imperf: subj{np(str)} + {cp(int)}
symbolizować: imperf: subj{np(str)} + {cp(że)}
symbolizować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
sympatyzować: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
sympatyzować: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
sypać: imperf: {np(inst)}
sypać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
sypać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
sypać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)}
sypać: imperf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
sypać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
sypać się: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
sypać się: imperf: subj{np(str)} + {prepnp(na,acc)}
sypnąć: perf: {np(inst)}
sypnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(po,loc)}
sypnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
sypnąć: perf: subj{np(str)} + {np(inst)} + {xp(abl)}
sypnąć: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(adl)}
sypnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
sypnąć się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
sypnąć się: perf: subj{np(str)} + {prepnp(na,acc)}
sytuować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)} + {advp(misc)}
sytuować się: imperf: subj{np(str)} + {xp(locat)} + {advp(misc)}
szacować: imperf: subj{np(str)} + {cp(że)}
szacować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szaleć: imperf: subj{np(str)} + {np(inst)}
szaleć: imperf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
szaleć: imperf: subj{np(str)} + {prepnp(na,loc)}
szaleć: imperf: subj{np(str)} + {prepnp(w,loc)}
szaleć: imperf: subj{np(str)} + {prepnp(za,inst)}
szaleć: imperf: subj{np(str)} + {prepnp(z,gen)}
szaleć: imperf: subj{np(str)} + {prepnp(z,inst)}
szaleć: imperf: subj{np(str)} + {xp(locat)}
szanować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
szanować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)}
szanować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
szanować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
szanować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
szanować się: imperf: subj{np(str)}
szarpać: imperf: {np(inst)} + {prepnp(po,loc)}
szarpać: imperf: {np(inst)} + {xp(adl)}
szarpać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szarpać: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
szarpać: imperf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
szarpać: imperf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
szarpać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
szarpać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
szarpać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
szarpać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
szarpać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
szarpać się: imperf: subj{np(str)} + {prepnp(na,acc)}
szarpać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
szarpać się: imperf: subj{np(str)} + {xp(adl)}
szarpnąć: perf: {np(inst)} + {xp(adl)}
szarpnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szarpnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
szarpnąć: perf: subj{np(str)} + obj{np(inst)} + {prepnp(po,loc)}
szarpnąć: perf: subj{np(str)} + obj{np(inst)} + {xp(adl)}
szarpnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
szarpnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
szarpnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
szarpnąć się: perf: subj{np(str)} + {prepnp(na,acc)}
szarpnąć się: perf: subj{np(str)} + {xp(adl)}
szczekać: imperf: subj{np(str)} + {np(str)}
szczekać: imperf: subj{np(str)} + {or}
szczekać: imperf: subj{np(str)} + {prepnp(na,acc)}
szczekać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
szczekać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
szczekać: imperf: subj{np(str)} + {prepnp(o,loc)}
szczekać: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
szczycić się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
szczycić się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
szczycić się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
szczycić się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(int)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',natr)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',natr)}
szepnąć: perf: subj{np(str)} + {np(dat)} + {or}
szepnąć: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
szepnąć: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',natr)} + {or}
szepnąć: perf: subj{np(str)} + {np(str)} + {prepnp(do,gen)}
szepnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {comprepnp(na temat)}
szepnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
szepnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
szepnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szepnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szepnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
szeptać: imperf: subj{np(str)} + {cp(int)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: imperf: subj{np(str)} + {cp(że)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {prepadjp(po,postp)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
szeptać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
szeptać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,jakoby); prepncp(o,loc,że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
szeptać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szeptać: imperf: subj{np(str)} + {prepadjp(po,postp)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: imperf: subj{np(str)} + {preplexnp(między,inst,sg,'siebie',natr)} + {or}
szeptać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
szeptać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
szeptać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
szeptać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
szeptać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepadjp(po,postp)}
szeptać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
szeptać: imperf: subj{np(str)} + {prepnp(o,loc)} + {preplexnp(między,inst,sg,'siebie',natr)}
szeptać: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(z,inst)}
szeptać: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepadjp(po,postp)}
szkoda: imperf: controller{np(dat)} + controllee{infp(_)}
szkoda: imperf: {np(dat)} + {cp(gdy)}
szkoda: imperf: {np(dat)} + {cp(jak)}
szkoda: imperf: {np(dat)} + {cp(kiedy)}
szkoda: imperf: {np(dat)} + {cp(że)}
szkoda: imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
szkoda: imperf: {np(dat)} + {np(gen); ncp(gen,że)}
szkoda: imperf: {np(dat)} + {np(gen)} + {prepnp(dla,gen)}
szkoda: imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen)}
szkoda: imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
szkodzić: imperf: subj,controllee{infp(_)} + controller{np(dat)} + {nonch}
szkodzić: imperf: subj{cp(żeby2)} + {np(dat)} + {nonch}
szkodzić: imperf: subj{cp(że)} + {np(dat)} + {nonch}
szkodzić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat); ncp(dat,żeby)} + {prepnp(na,acc)}
szkolić: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
szkolić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
szkolić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szkolić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
szkolić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
szkolić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
szkolić się: imperf: subj{np(str)} + {cp(int)}
szkolić się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
szkolić się: imperf: subj{np(str)} + {prepnp(na,acc)}
szkolić się: imperf: subj{np(str)} + {prepnp(na,loc)}
szkolić się: imperf: subj{np(str)} + {prepnp(w,loc)}
szkolić się: imperf: subj{np(str)} + {prepnp(z,gen)}
szorować: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
szorować: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
szorować: imperf: subj{np(str)} + {np(inst)} + {refl}
szorować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
szorować: imperf: subj{np(str)} + {xp(adl)}
szukać: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(u,gen); xp(locat)}
szukać: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(w,loc)}
szukać: imperf: subj{np(str)} + {xp(locat)} + {refl}
szumieć: imperf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
szumieć: imperf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
szumieć: imperf: {prepnp(o,loc); prepncp(o,loc,że)} + {xp(locat)}
szumieć: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
szumieć: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
szumieć: imperf: subj{np(str)} + {np(inst)}
szumieć: imperf: subj{np(str)} + {prepnp(od,gen)}
szumieć: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
szumieć: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
szyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
szyć: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
szyć: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
szyć: imperf: subj{np(str)} + {xp(perl)}
szydzić: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
szydzić: imperf: subj{np(str)} + {prepnp(z,gen)} + {or}
szydzić: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
szykować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
szykować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
szykować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
szykować: imperf: subj{np(str)} + {prepnp(do,gen)} + {refl}
szykować: imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
szykować się: imperf: subj,controller{np(str)} + controllee{infp(_)}
szykować się: imperf: subj{np(str)} + {xp(locat)}
ściągać: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(adl)}
ściągać: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(na,acc,sg,'głowa',natr)}
ściągać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ściągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ściągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ściągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
ściągać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ściągnąć: perf: subj{np(str)} + {np(dat)} + {np(str)} + {preplexnp(na,acc,sg,'głowa',natr)}
ściągnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ściągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ściągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
ściągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
ściągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
ściągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ściągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
ściągnąć się: perf: subj{np(str)} + {np(dat)}
ś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)}
ś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)}
ślizgać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
ślizgać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
ślizgać się: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
ślizgać się: imperf: subj{np(str)} + {np(inst)} + {xp(locat)}
ślizgać się: imperf: subj{np(str)} + {prepnp(na,loc)}
ślubować: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że); infp(_)} + {np(dat)} + {prepnp(na,acc)}
śmiać się: imperf: subj{lexnp(str,_,'oko',natr)} + {np(dat)} + {prepnp(do,gen)}
śmiać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
śmiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
śmiać się: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
śmiać się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
śmieć: imperf: subj,controller{np(str)} + controllee{infp(_)}
śmierdzieć: imperf: controller{np(dat)} + controllee{xp(mod)} + {xp(abl)}
śmierdzieć: imperf: controller{prepnp(od,gen)} + controllee{xp(mod)}
śmierdzieć: imperf: controller{xp(locat)} + controllee{xp(mod)}
śmierdzieć: imperf: {np(dat)} + {np(inst)} + {xp(abl)}
śmierdzieć: imperf: {np(inst)} + {prepnp(od,gen)}
śmierdzieć: imperf: {np(inst)} + {xp(locat)}
śmierdzieć: imperf: subj,controller{np(str)} + controllee{xp(mod)}
śmierdzieć: imperf: subj{np(str)} + {np(inst)}
śmieszyć: imperf: subj{cp(gdy)} + {np(str)}
śmieszyć: imperf: subj{cp(int)} + {np(str)}
śmieszyć: imperf: subj{cp(jak)} + {np(str)}
śmieszyć: imperf: subj{cp(jeśli)} + {np(str)}
śmieszyć: imperf: subj{cp(kiedy)} + {np(str)}
śmieszyć: imperf: subj{cp(że)} + {np(str)}
śmieszyć: imperf: subj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,jeśli); ncp(str,kiedy); ncp(str,że)} + {np(str)}
śnić: imperf: subj{np(str)} + {cp(jak)}
śnić: imperf: subj{np(str)} + {np(str)}
śnić: imperf: subj{np(str)} + {prepnp(o,loc); cp(że); prepncp(o,loc,że)}
śnić się: imperf: controller{np(dat)} + controllee{infp(_)}
śnić się: imperf: {np(dat)} + {prepnp(o,loc)}
śnić się: imperf: subj{cp(jak)} + {np(dat)}
śnić się: imperf: subj{cp(żeby)} + {np(dat)}
śnić się: imperf: subj{np(str); cp(że); ncp(str,że)} + {np(dat)}
śpieszyć: imperf: subj,controller{np(str)} + controllee{infp(_)}
śpieszyć: imperf: subj{np(str)} + {np(dat)} + {np(str)}
śpieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
śpieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
śpieszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
śpieszyć: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(ku,dat); prepnp(na,acc); xp(adl)} + {xp(perl)}
śpieszyć się: imperf: {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
śpieszyć się: imperf: subj,controller{np(str)} + controllee{infp(_)}
śpieszyć się: imperf: subj{np(str)} + {np(dat)} + {np(str)}
śpieszyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
śpieszyć się: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc); prepncp(do,gen,żeby); xp(adl)}
śpieszyć się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
śpiewać: imperf: subj{np(str)} + {cp(że)}
śpiewać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
śpiewać: imperf: subj{np(str)} + {np(inst)} + {or}
śpiewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
świadczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
świadczyć: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'rzecz',ratr)}
świadczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
świadczyć: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
świadczyć: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'niekorzyść',ratr)}
świadczyć: imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że)} + {advp(misc)}
świadczyć: imperf: subj{np(str)} + {prepnp(o,loc)} + {prepnp(przed,inst)}
świadczyć: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)} + {prepnp(przed,inst)} + {cp(że)}
świecić: imperf: subj{np(str)} + {cp(że)} + {lexnp(inst,pl,'oko',natr)}
świecić: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
świecić: imperf: subj{np(str)} + {np(inst)}
świecić: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc)} + {lexnp(inst,pl,'oko',natr)}
świecić się: imperf: subj{lexnp(str,pl,'oko',atr)} + {np(dat)} + {prepnp(do,gen)}
świecić się: imperf: subj{np(str)}
świętować: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
świętować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
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); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
telefonować: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
testować: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,inst,sg,'wzgląd',ratr)}
testować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
tępić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
tępić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
tępić się: imperf: subj{np(str)} + {np(dat)}
tęsknić: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
tęsknić: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,ż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{np(str); ncp(str,że)} + {np(str)}
tłumaczyć: imperf: subj{np(str)} + {np(dat)} + {or}
tłumaczyć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepadjp(na,acc)} + {prepadjp(z,gen)}
tłumaczyć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,gen)}
tłumaczyć: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
tłumaczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
tłumaczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)}
tłumaczyć się: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
tłumaczyć się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
tłumaczyć się: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
tłumaczyć się: imperf: subj{np(str)} + {np(dat)} + {or}
tłumaczyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
tłumaczyć się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
tłumaczyć się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
tłumaczyć się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
tłumaczyć się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
tłumaczyć się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
tłumić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
to: imperf: subj,controller{cp(żeby)} + controllee{advp(misc)}
to: imperf: subj,controller{cp(żeby)} + controllee{np(nom)}
to: imperf: subj,controller{cp(że)} + controllee{advp(misc)}
to: imperf: subj,controller{cp(że)} + controllee{np(nom)}
to: imperf: subj,controller{infp(_)} + controllee{infp(_)}
to: imperf: subj,controller{infp(_)} + controllee{np(nom)}
to: imperf: subj,controller{np(str); ncp(str,że)} + controllee{np(nom)}
toczyć: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
toczyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
toczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
toczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
toczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
toczyć: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
toczyć się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
toczyć się: imperf: subj{lexnp(str,sg,'fortuna',natr)} + {lexnp(inst,sg,'koło',natr)}
toczyć się: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
toczyć się: imperf: subj{np(str)} + {xp(adl)}
toczyć się: imperf: subj{np(str)} + {xp(locat)}
tolerować: imperf: subj{np(str)} + {cp(gdy)}
tolerować: imperf: subj{np(str)} + {cp(jak)}
tolerować: imperf: subj{np(str)} + {cp(jeśli)}
tolerować: imperf: subj{np(str)} + {cp(kiedy)}
tolerować: imperf: subj{np(str)} + {cp(że)}
tolerować: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)}
tolerować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
tolerować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tolerować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
tonąć: imperf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
topić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
topić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
topić się: imperf: subj{np(str)} + {np(dat)}
towarzyszyć: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
towarzyszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
towarzyszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
towarzyszyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
towarzyszyć: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
towarzyszyć: imperf: subj{np(str)} + {np(dat)} + {xp(temp)}
tracić: imperf: subj{np(str)} + {lexnp(str,sg,'grunt',natr)} + {preplexnp(pod,inst,pl,'noga',natr)}
tracić: imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,pl,'oko',natr)}
tracić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
tracić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
tracić: imperf: subj{np(str)} + {preplexnp(w,loc,pl,'oko',ratr)}
tracić: imperf: subj{np(str)} + {prepnp(dla,gen)} + {lexnp(str,sg,'serce',natr)}
tracić: imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,sg,'serce',natr)}
tracić: imperf: subj{np(str)} + {prepnp(z,gen)} + {nonch}
trafiać: imperf: {prepnp(na,acc)}
trafiać: imperf: subj{cp(int)} + {prepnp(do,gen)}
trafiać: imperf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
trafiać: imperf: subj{cp(że)} + {prepnp(do,gen)}
trafiać: imperf: subj{np(str); ncp(str,że)} + {prepnp(do,gen)}
trafiać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
trafiać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
trafiać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trafiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trafiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
trafiać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
trafiać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
trafiać: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
trafiać: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
trafiać: imperf: subj{np(str)} + {prepnp(za,acc)}
trafiać: imperf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
trafiać: imperf: subj{np(str)} + {xp(adl)}
trafiać się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
trafiać się: imperf: subj{cp(że)} + {np(dat)}
trafiać się: imperf: subj{np(str)} + {np(dat)}
trafić: perf: {prepnp(na,acc)}
trafić: perf: subj{cp(int)} + {prepnp(do,gen)}
trafić: perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen)}
trafić: perf: subj{cp(że)} + {prepnp(do,gen)}
trafić: perf: subj{np(str); ncp(str,że)} + {prepnp(do,gen)}
trafić: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
trafić: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
trafić: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trafić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
trafić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
trafić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
trafić: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
trafić: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,gen)}
trafić: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
trafić: perf: subj{np(str)} + {prepnp(za,inst)}
trafić: perf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
trafić: perf: subj{np(str)} + {xp(adl)}
trafić się: perf: subj,controllee{infp(_)} + controller{np(dat)}
trafić się: perf: subj{cp(że)} + {np(dat)}
trafić się: perf: subj{np(str)} + {np(dat)}
traktować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
traktować: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {refl}
traktować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
traktować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
traktować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
traktować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
traktować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
traktować: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
trącać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
trącać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
trącić: imperf: subj{np(str)} + {np(inst)}
trącić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
trącić się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
trenować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
trenować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
trenować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
trenować: imperf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(z,inst)}
trenować: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
trenować się: imperf: subj{np(str)} + {prepnp(w,loc)}
triumfować: imperf: subj{np(str)} + {cp(że)}
triumfować: imperf: subj{np(str)} + {np(inst)}
triumfować: imperf: subj{np(str)} + {or}
triumfować: imperf: subj{np(str)} + {prepnp(nad,inst)} + {prepnp(w,loc)}
tropić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
tropić: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
tropić: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
tropić: imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(locat)}
tropić: imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(perl)}
tropić się: imperf: subj{np(str)}
troszczyć się: imperf: subj{np(str)} + {cp(int)}
troszczyć się: imperf: subj{np(str)} + {cp(że)}
troszczyć się: imperf: subj{np(str)} + {cp(żeby)}
troszczyć się: imperf: subj{np(str)} + {np(inst)}
troszczyć się: imperf: subj{np(str)} + {or}
troszczyć się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
trudnić się: imperf: subj{np(str)} + {np(inst)}
trwać: imperf: subj,controller{np(str)} + controllee{xp(mod)}
trwać: imperf: subj{np(str)} + {prepnp(przy,loc)}
trwać: imperf: subj{np(str)} + {prepnp(w,loc)}
trwać: imperf: subj{np(str)} + {xp(dur)}
trwać: imperf: subj{np(str)} + {xp(locat)}
tryskać: imperf: {np(inst)} + {prepnp(od,gen)}
tryskać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)} + {prepnp(z,gen)}
tryskać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
tryskać: imperf: subj{np(str)} + {prepnp(od,gen)}
trząść: imperf: {np(inst)}
trząść: imperf: obj{np(str)}
trząść: imperf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)}
trząść: imperf: subj{np(str)} + obj{np(str)}
trząść się: imperf: subj,controller{np(str)} + controllee{prepnp(jak,str)}
trząść się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepnp(z,gen)}
trząść się: imperf: subj{np(str)} + {prepnp(do,gen)}
trząść się: imperf: subj{np(str)} + {prepnp(nad,inst)}
trząść się: imperf: subj{np(str)} + {prepnp(o,acc)}
trzeba: imperf: {advp(pron)}
trzeba: imperf: controller{np(dat)} + controllee{infp(_)} + {cp(żeby)}
trzeba: imperf: {np(dat)} + {np(gen)} + {cp(żeby)}
trzeba: imperf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
trzeba: imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
trzeba: imperf: {np(gen)} + {cp(że)}
trzeć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzeć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
trzeć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
trzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
trzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
trzeć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzepać: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
trzepać: imperf: subj{np(str)} + {np(inst)} + {or}
trzepać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzepać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzepać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
trzepać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzepać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
trzepać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
trzepać się: imperf: subj{np(str)} + {xp(locat)}
trzepnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
trzepnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
trzepnąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
trzepnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
trzepnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
twierdzić: imperf: subj{np(str)} + {advp(pron)}
twierdzić: imperf: subj{np(str)} + {cp(jakoby)}
twierdzić: imperf: subj{np(str)} + {cp(że)}
twierdzić: imperf: subj{np(str)} + {cp(żeby)}
twierdzić: imperf: subj{np(str)} + {nonch}
twierdzić: imperf: subj{np(str)} + {or}
tworzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
tworzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
tworzyć się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
tworzyć się: imperf: subj{np(str)} + {prepnp(z,gen)}
tyć: imperf: subj{np(str)} + {comprepnp(z powodu)}
tyć: imperf: subj{np(str)} + {np(str)}
tyć: imperf: subj{np(str)} + {prepnp(na,loc)}
tyć: imperf: subj{np(str)} + {prepnp(o,acc)}
tyć: imperf: subj{np(str)} + {prepnp(od,gen)}
tyć: imperf: subj{np(str)} + {prepnp(z,gen)}
ubezpieczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {prepnp(u,gen); xp(locat)}
ubezpieczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ubezpieczać się: imperf: subj{np(str)} + {prepnp(na,gen); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {prepnp(u,gen); xp(locat)}
ubezpieczać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
ubezpieczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {prepnp(u,gen); xp(locat)}
ubezpieczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ubezpieczyć się: perf: subj{np(str)} + {prepnp(na,acc); prepnp(od,gen); prepncp(od,gen,że); prepncp(od,gen,żeby)} + {prepnp(u,gen); xp(locat)}
ubezpieczyć się: perf: subj{np(str)} + {prepnp(przed,inst)}
ubiec: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ubiec: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
ubiegać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
ubiegać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
ubiegać się: imperf: subj{np(str)} + {cp(żeby)}
ubiegać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
ubierać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ubierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ubierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ubierać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ubierać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
ubierać się: imperf: subj{np(str)} + {prepnp(u,gen)}
ubierać się: imperf: subj{np(str)} + {xp(locat)}
ubolewać: imperf: subj{np(str)} + {cp(że)}
ubolewać: imperf: subj{np(str)} + {or}
ubolewać: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
ubrać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ubrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ubrać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ubrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ubrać: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
ubrać się: perf: subj,controller{np(str)} + controllee{xp(mod)}
ubrać się: perf: subj{np(str)} + {prepnp(u,gen)}
ubrać się: perf: subj{np(str)} + {xp(locat)}
uchodzić: imperf: controller{np(dat)} + controllee{infp(_)}
uchodzić: imperf: subj,controller{cp(że)} + controllee{prepnp(za,acc)}
uchodzić: imperf: subj,controller{infp(_)} + controllee{prepnp(za,acc)}
uchodzić: imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)}
uchodzić: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)}
uchodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
uchodzić: imperf: subj{np(str)} + {xp(abl)}
uchwalić: perf: subj{np(str)} + {cp(że)}
uchwalić: perf: subj{np(str)} + {cp(żeby)}
uchwalić: perf: subj{np(str)} + obj{np(str)}
uchwalić: perf: subj{np(str)} + {or}
uchwycić: perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
uchwycić: perf: subj{np(str)} + obj{cp(jak)} + {np(inst)}
uchwycić: perf: subj{np(str)} + obj{cp(kiedy)} + {np(inst)}
uchwycić: perf: subj{np(str)} + obj{cp(że)} + {np(inst)}
uchwycić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + {np(inst)}
uchwycić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
uchwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
uchwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uchwycić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uchwycić: perf: subj{np(str)} + {prepnp(na,loc)} + {refl}
uchwycić: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
uchwycić się: perf: subj{np(str)} + {np(gen)} + {np(inst)}
uchwycić się: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ucierpieć: perf: subj{np(str)} + {prepnp(od,gen); prepnp(przez,acc); comprepnp(z powodu); prepncp(od,gen,że); prepncp(przez,acc,że); xp(temp); preplexnp(na,acc,sg,'skutek',natr); preplexnp(w,loc,sg,'wynik',natr)} + {advp(misc)}
ucieszyć: perf: subj{cp(że)} + {np(str)}
ucieszyć: perf: subj{np(str); ncp(str,że)} + obj{np(str)}
ucieszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ucieszyć się: perf: subj{np(str)} + {cp(że)}
ucieszyć się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
ucieszyć się: perf: subj{np(str)} + {or}
ucieszyć się: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
uczcić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
uczestniczyć: imperf: subj{np(str)} + {prepnp(w,loc)}
uczęszczać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
uczęszczać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
uczyć: imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
uczyć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {np(inst)}
uczyć: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)} + {nonch}
uczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
uczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {nonch}
uczyć się: imperf: subj,controller{np(str)} + controllee{np(gen); prepnp(o,loc); cp(int); cp(że); cp(żeby); ncp(gen,int); ncp(gen,że); ncp(gen,żeby); prepncp(o,loc,int); prepncp(o,loc,że); infp(imperf)} + {prepnp(od,gen); prepnp(z,gen); prepnp(z,inst)}
uczyć się: imperf: subj{np(str)} + {advp(misc)}
uczyć się: imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
uczyć się: imperf: subj{np(str)} + {np(gen)} + {prepnp(do,gen)}
uczyć się: imperf: subj{np(str)} + {np(gen)} + {prepnp(u,gen)}
uczyć się: imperf: subj{np(str)} + {np(gen)} + {xp(locat)}
uczyć się: imperf: subj{np(str)} + {preplexnp(na,loc,pl,'błąd',batr)}
uczyć się: imperf: subj{np(str)} + {prepnp(na,acc)}
uczyć się: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(od,gen); prepnp(z,gen)} + {nonch}
uczynić: perf: subj{np(str)} + {cp(że)} + {advp(misc)}
uczynić: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
uczynić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uczynić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uczynić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uczynić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uczynić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
uczynić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uczynić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uczynić się: perf: {np(dat)} + {xp(locat)} + {advp(misc)}
uczynić się: perf: subj,controller{np(str)} + controllee{adjp(pred)}
udać: perf: subj,controller{np(str)} + controllee{adjp(str)}
udać: perf: subj,controller{np(str)} + controllee{np(str)}
udać: perf: subj{np(str)} + {cp(że)}
udać: perf: subj{np(str)} + obj{np(str)}
udać się: perf: controller{np(dat)} + controllee{infp(_)}
udać się: perf: subj{np(str)} + {np(dat)}
udać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
udać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
udać się: perf: subj{np(str)} + {xp(adl)}
udaremnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
udawać: imperf: subj,controller{np(str)} + controllee{adjp(str)}
udawać: imperf: subj,controller{np(str)} + controllee{np(str)}
udawać: imperf: subj{np(str)} + {cp(że)}
udawać: imperf: subj{np(str)} + obj{np(str)}
udawać się: imperf: controller{np(dat)} + controllee{infp(_)}
udawać się: imperf: subj{np(str)} + {np(dat)}
udawać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
udawać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
udawać się: imperf: subj{np(str)} + {xp(adl)}
uderzać: imperf: subj{cp(że)} + {np(str)}
uderzać: imperf: subj{lexnp(str,sg,'serce',natr)} + {np(dat)} + {advp(misc)}
uderzać: imperf: subj{np(str); ncp(str,że)} + {np(str)}
uderzać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uderzać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzać: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
uderzać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
uderzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
uderzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
uderzać: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
uderzać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uderzać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
uderzać: imperf: subj{np(str)} + {prepnp(na,acc)}
uderzać: imperf: subj{np(str)} + {prepnp(na,loc)}
uderzać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
uderzyć: perf: subj{cp(że)} + {np(str)}
uderzyć: perf: subj{np(str); ncp(str,że)} + {np(str)}
uderzyć: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
uderzyć: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzyć: perf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)} + {refl}
uderzyć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
uderzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
uderzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzyć: perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
uderzyć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uderzyć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
uderzyć: perf: subj{np(str)} + {prepnp(na,acc)}
uderzyć: perf: subj{np(str)} + {prepnp(na,loc)}
uderzyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
uderzyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
uderzyć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
udokumentować: perf: subj{np(str)} + obj{cp(int); cp(że)} + {np(inst)}
udokumentować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
udostępniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepnp(pod,acc)} + {xp(locat)}
udostępniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
udostępnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen); prepnp(na,acc); prepnp(pod,acc)} + {xp(locat)}
udostępnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
udowadniać: imperf: subj{np(str)} + {np(dat)} + {or}
udowadniać: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
udowadniać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
udowadniać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
udowodnić: perf: subj{np(str)} + {np(dat)} + {or}
udowodnić: perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
udowodnić: perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
udowodnić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)}
udzielać: imperf: subj{np(str)} + obj{np(gen)} + {np(dat)}
udzielać się: imperf: subj{np(str)} + {advp(misc)}
udzielać się: imperf: subj{np(str)} + {np(dat)}
udzielać się: imperf: subj{np(str)} + {prepnp(na,loc)}
udzielać się: imperf: subj{np(str)} + {prepnp(w,loc)}
udzielić: perf: subj{np(str)} + obj{np(gen)} + {np(dat)}
udzielić się: perf: subj{np(str)} + {advp(misc)}
udzielić się: perf: subj{np(str)} + {np(dat)}
udzielić się: perf: subj{np(str)} + {prepnp(na,loc)}
udzielić się: perf: subj{np(str)} + {prepnp(w,loc)}
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)}
ugiąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ugiąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
ugiąć: perf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(gen,sg,'kark',batr)}
ugiąć się: perf: subj{np(str)} + {prepnp(od,gen)}
ugiąć się: perf: subj{np(str)} + {prepnp(pod,inst)}
ugiąć się: perf: subj{np(str)} + {prepnp(przed,inst)}
uginać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
uginać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uginać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {lexnp(gen,sg,'kark',batr)}
uginać się: perf: subj{np(str)} + {prepnp(od,gen)}
uginać się: perf: subj{np(str)} + {prepnp(pod,inst)}
uginać się: perf: subj{np(str)} + {prepnp(przed,inst)}
ugotować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ugotować: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
ugotować się: perf: subj{np(str)} + {prepnp(od,gen)}
ugotować się: perf: subj{np(str)} + {prepnp(w,loc)}
ugotować się: perf: subj{np(str)} + {xp(locat)}
ugryźć: perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
ugryźć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ugryźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ugryźć: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
uhonorować: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst); ncp(inst,że)}
uiścić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ujawnić: perf: subj{np(str)} + obj{cp(int); cp(że)} + {np(dat)}
ujawnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ujawnić się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
ujawnić się: perf: subj{np(str)} + {np(dat)}
ujawnić się: perf: subj{np(str)} + {xp(locat)}
ujawnić się: perf: subj{np(str)} + {xp(temp)}
ująć: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {or}
ująć: perf: subj{cp(że)} + {np(str)} + {prepnp(w,loc)}
ująć: perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
ująć: perf: subj{np(str)} + {np(dat)} + {np(gen)}
ująć: perf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
ująć: perf: subj{np(str)} + obj{cp(że)}
ująć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ująć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ująć: perf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
ująć: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
ująć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ująć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ująć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
ująć: perf: subj{np(str)} + {prepnp(pod,acc)} + {refl}
ująć: perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
ująć się: perf: subj{np(str)} + {lexnp(inst,sg,'honor',natr)}
ująć się: perf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)} + {or}
ujmować: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)} + {or}
ujmować: imperf: subj{cp(że)} + {np(str)} + {prepnp(w,loc)}
ujmować: imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
ujmować: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
ujmować: imperf: subj{np(str)} + {np(gen)} + {prepnp(z,gen)}
ujmować: imperf: subj{np(str)} + obj{cp(że)}
ujmować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
ujmować: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
ujmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(między,acc)}
ujmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
ujmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ujmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ujmować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
ujmować: imperf: subj{np(str)} + {prepnp(pod,acc)} + {refl}
ujmować: imperf: subj{np(str)} + {prepnp(za,acc)} + {refl}
ujmować się: imperf: subj{np(str)} + {lexnp(inst,sg,'honor',natr)}
ujmować się: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)} + {or}
ujrzeć: perf: subj{np(str)} + {cp(int)}
ujrzeć: perf: subj{np(str)} + {cp(jak)}
ujrzeć: perf: subj{np(str)} + {cp(że)}
ujrzeć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,pl,'oko',batr)}
ujrzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ukarać: perf: subj{np(str)} + {np(inst)} + {prepncp(za,acc,że)} + {refl}
ukarać: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
ukarać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepncp(za,acc,że)}
ukarać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
ukazać: perf: subj{np(str)} + {cp(int)}
ukazać: perf: subj{np(str)} + {cp(że)}
ukazać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ukazać: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
ukazać się: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
ukazać się: perf: subj{np(str)} + {np(dat)}
ukazać się: perf: subj{np(str)} + {xp(locat)}
ukazywać: imperf: subj{np(str)} + {cp(int)}
ukazywać: imperf: subj{np(str)} + {cp(że)}
ukazywać: imperf: subj{np(str)} + {ncp(str,int)}
ukazywać: imperf: subj{np(str)} + {ncp(str,że)}
ukazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ukazywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ukazywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
ukazywać się: imperf: subj{np(str)} + {np(dat)}
ukazywać się: imperf: subj{np(str)} + {xp(locat)}
układać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
układać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
układać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)} + {advp(misc)}
układać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
układać się: imperf: subj{np(str)} + {np(dat)} + {advp(misc)}
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(na,loc)} + {advp(misc)}
układać się: imperf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
układać się: imperf: subj{np(str)} + {prepnp(pod,acc)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
układać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
układać się: imperf: subj{np(str)} + {xp(locat)}
ukończyć: perf: subj{np(str)} + obj{np(str)}
ukraść: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
ukryć: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {prepnp(przed,inst)} + {xp(locat)}
ukryć: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
ukryć: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
ukrywać: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {prepnp(przed,inst)} + {xp(locat)}
ukrywać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'sobie',natr)}
ukrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,inst)}
ukrywać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
ukrywać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(locat)} + {refl}
ukrywać się: imperf: subj{np(str)} + {prepnp(pod,inst)}
ukrywać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
ukształtować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
ukształtować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ukształtować się: perf: subj{np(str)} + {np(inst)}
ukształtować się: perf: subj{np(str)} + {xp(locat)}
ulec: perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ulec: perf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ulec: perf: subj{np(str)} + {np(dat); ncp(dat,że)}
ulec: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulegać: imperf: subj{cp(int)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: imperf: subj{cp(int)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: imperf: subj{cp(że)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: imperf: subj{cp(że)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'kwestia',atr)}
ulegać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(dat,sg,'wątpliwość',atr)}
ulegać: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
ulegać: imperf: subj{np(str)} + {np(dat)} + {comprepnp(w sprawie)}
ulegać: imperf: subj{np(str)} + {np(dat); ncp(dat,że)}
ulegać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ulokować: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
ulokować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
ulokować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ulokować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
ulokować się: perf: subj{np(str)} + {prepnp(u,gen)}
ulokować się: perf: subj{np(str)} + {xp(locat)}
ułatwiać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
ułatwić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)}
ułożyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{infp(imperf)}
ułożyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
ułożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)} + {advp(misc)}
ułożyć się: perf: subj,controller{np(str)} + controllee{infp(_)}
ułożyć się: perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(na,loc)}
ułożyć się: perf: subj{np(str)} + {np(dat)} + {advp(misc)}
ułożyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
ułożyć się: perf: subj{np(str)} + {prepnp(do,gen)} + {advp(misc)}
ułożyć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(z,inst)}
ułożyć się: perf: subj{np(str)} + {prepnp(pod,acc)}
ułożyć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(co do)}
ułożyć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
ułożyć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
ułożyć się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
ułożyć się: perf: subj{np(str)} + {xp(locat)}
umarzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
umawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
umawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
umawiać się: imperf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)} + {prepnp(z,inst)}
umawiać się: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(z,inst)}
umawiać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
umawiać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
umawiać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
umawiać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,int)}
umawiać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,że)}
umawiać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)} + {xp(temp)}
umieć: imperf: subj,controller{np(str)} + controllee{np(str); infp(_)}
umieć: imperf: subj{np(str)} + {prepadjp(po,postp)}
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)}
umknąć: perf: subj{cp(int)} + {lexnp(gen,sg,'uwaga',ratr)}
umknąć: perf: subj{cp(int)} + {np(dat)}
umknąć: perf: subj{cp(że)} + {lexnp(gen,sg,'uwaga',ratr)}
umknąć: perf: subj{cp(że)} + {np(dat)}
umknąć: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {lexnp(gen,sg,'uwaga',ratr)}
umknąć: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
umknąć: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
umknąć: perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)} + {xp(adl)}
umknąć: perf: subj{np(str)} + {prepnp(przed,inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
umożliwiać: imperf: subj{ncp(str,że)} + obj{np(str)}
umożliwiać: imperf: subj{np(str)} + {cp(że)}
umożliwiać: imperf: subj{np(str)} + {cp(żeby)}
umożliwiać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {infp(_)}
umożliwiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
umożliwić: perf: subj{ncp(str,że)} + obj{np(str)}
umożliwić: perf: subj{np(str)} + {cp(że)}
umożliwić: perf: subj{np(str)} + {cp(żeby)}
umożliwić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {infp(_)}
umożliwić: perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
umówić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
umówić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
umówić się: perf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że)} + {prepnp(z,inst)}
umówić się: perf: subj{np(str)} + {prepnp(do,gen); prepnp(na,acc)} + {prepnp(z,inst)}
umówić się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
umówić się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
umówić się: perf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,int)}
umówić się: perf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(na,acc,że)}
umówić się: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)} + {xp(temp)}
umrzeć: perf: {preplexnp(w,loc,pl,'but',natr)}
umrzeć: perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
umrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepnp(od,gen); prepnp(wskutek,gen); prepnp(z,gen); comprepnp(z powodu)}
umrzeć: perf: subj{np(str)} + {prepnp(dla,gen)}
umrzeć: perf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że); prepncp(za,acc,żeby)}
umyć: perf: subj{np(str)} + {np(inst)} + {refl}
umyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umyć: perf: subj{np(str)} + {prepnp(od,gen)} + {lexnp(str,pl,'ręka',natr)}
umywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
umywać: imperf: subj{np(str)} + {prepnp(od,gen)} + {lexnp(str,pl,'ręka',natr)}
umywać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
umywać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {preplexnp(pod,inst,sg,'wzgląd',natr)}
uniemożliwiać: imperf: subj{np(str)} + {cp(żeby)}
uniemożliwiać: imperf: subj{np(str)} + {ncp(str,żeby)}
uniemożliwiać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {infp(_)}
uniemożliwiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uniemożliwić: perf: subj{np(str)} + {cp(żeby)}
uniemożliwić: perf: subj{np(str)} + {ncp(str,żeby)}
uniemożliwić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {infp(_)}
uniemożliwić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
unieważniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
unieważnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uniewinniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uniewinniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uniewinniać: imperf: subj{np(str)} + {or} + {refl}
uniewinnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uniewinnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
uniewinnić: perf: subj{np(str)} + {refl}
unikać: imperf: subj{np(str)} + obj{np(gen); ncp(gen,że); ncp(gen,żeby)}
uniknąć: perf: subj{np(str)} + obj{np(gen); ncp(gen,że); ncp(gen,żeby)}
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)} + controllee{xp(mod)}
upić się: perf: subj{np(str)} + {np(inst)}
upiec: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
upiec: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
upiec: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
upiec się: perf: {np(dat)}
upiec się: perf: subj{np(str)} + {prepnp(na,loc)}
upiec się: perf: subj{np(str)} + {prepnp(w,loc)}
upierać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
upierać się: imperf: subj{np(str)} + {cp(że)}
upierać się: imperf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)}
upierać się: imperf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)} + {or}
upijać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(z,gen)}
upijać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
upijać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
upijać się: imperf: subj{np(str)} + {np(inst)}
uplasować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
uplasować się: perf: subj{np(str)} + {xp(locat)}
upłynąć: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
upłynąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
upłynąć: perf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
upłynąć: perf: subj{np(str)} + {np(dat)} + {prepnp(wśród,gen)}
upłynąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
upłynąć: perf: subj{np(str)} + {np(str)}
upłynąć: perf: subj{np(str)} + {xp(temp)}
upływać: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)}
upływać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
upływać: imperf: subj{np(str)} + {np(dat)} + {prepnp(przy,loc)}
upływać: imperf: subj{np(str)} + {np(dat)} + {prepnp(wśród,gen)}
upływać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
upływać: imperf: subj{np(str)} + {xp(temp)}
upokarzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
upokarzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
upokarzać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
upokarzać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
upokorzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
upokorzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(wobec,gen)}
upokorzyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
upokorzyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
upominać: imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
upominać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {or}
upominać się: imperf: subj{np(str)} + {cp(żeby)} + {xp(locat)}
upominać się: imperf: subj{np(str)} + {or}
upominać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
upominać się: imperf: subj{np(str)} + {prepnp(za,inst)}
upomnieć: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
upomnieć: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upomnieć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
upomnieć: perf: subj{np(str)} + obj{np(str)} + {or}
upomnieć: perf: subj{np(str)} + obj{np(str)} + {prepncp(za,acc,że)}
upomnieć się: perf: subj{np(str)} + {cp(że)}
upomnieć się: perf: subj{np(str)} + {prepncp(o,acc,żeby)}
upomnieć się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(u,gen)} + {or}
upomnieć się: perf: subj{np(str)} + {prepnp(u,gen)} + {cp(żeby)}
upomnieć się: perf: subj{np(str)} + {prepnp(za,inst)}
uporać się: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że); prepncp(z,inst,żeby)}
uporządkować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uporządkować się: perf: subj{np(str)}
upoważniać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upoważniać: imperf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
upoważniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
upoważnić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
upoważnić: perf: subj{np(str)} + obj{np(str)} + {prepncp(do,gen,żeby)}
upoważnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
upowszechniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wśród,gen)}
upowszechniać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
upowszechniać się: imperf: subj{np(str)} + {prepnp(wśród,gen)}
upowszechniać się: imperf: subj{np(str)} + {xp(locat)}
uprawniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
uprościć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
uprościć się: perf: subj{np(str)}
uprzeć się: perf: subj,controller{np(str)} + controllee{infp(_)}
uprzeć się: perf: subj{np(str)} + {cp(że)}
uprzeć się: perf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,żeby)} + {or}
uprzeć się: perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,że); prepncp(przy,loc,żeby)} + {or}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {or}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,żeby)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uprzedzać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
uprzedzać się: imperf: subj{np(str)} + {prepnp(do,gen)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {cp(że); cp(żeby)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {or}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepncp(o,loc,żeby)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uprzedzić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
uprzedzić się: perf: subj{np(str)} + {prepnp(do,gen)}
uprzemysłowić: perf: subj{np(str)} + obj{np(str)}
uprzemysłowić się: perf: subj{np(str)}
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)}
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)}
urodzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
urodzić się: perf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
urodzić się: perf: subj,controller{np(str)} + controllee{np(inst)}
urodzić się: perf: subj{np(str)} + {np(dat)}
urodzić się: perf: subj{np(str)} + {prepnp(w,loc)}
urodzić się: perf: subj{np(str)} + {xp(locat)}
urodzić się: perf: subj{np(str)} + {xp(temp)}
uruchamiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uruchamiać się: imperf: subj{np(str)} + {np(dat)}
uruchomić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uruchomić się: perf: subj{np(str)} + {np(dat)}
urwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
urwać: perf: subj{np(str)} + {or}
urwać się: perf: {E}
urwać się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urwać się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urwać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
urwać się: perf: subj{np(str)} + {xp(locat)}
urywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,gen)}
urywać: imperf: subj{np(str)} + {or}
urywać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
urywać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
urywać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
urywać się: imperf: subj{np(str)} + {xp(locat)}
urządzać: imperf: subj{np(str)} + {np(str)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
urządzać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
urządzać się: imperf: subj{np(str)} + {prepnp(u,gen)}
urządzać się: imperf: subj{np(str)} + {xp(locat)}
urządzić: perf: subj{np(str)} + {np(inst)} + {refl}
urządzić: perf: subj{np(str)} + {np(str)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
urządzić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
urządzić się: perf: subj{np(str)} + {prepnp(u,gen)}
urządzić się: perf: subj{np(str)} + {xp(locat)}
urzędować: imperf: subj{np(str)} + {xp(dur)} + {xp(locat)}
usiłować: imperf: subj,controller{np(str)} + controllee{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}
uspokajać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)}
uspokajać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
uspokajać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
uspokajać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uspokajać: imperf: subj{np(str)} + obj{np(str)} + {or}
uspokajać się: imperf: subj{np(str)} + {cp(że)}
uspokajać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
uspokoić: perf: subj{np(str); ncp(str,że)} + obj{np(str)}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
uspokoić: perf: subj{np(str)} + obj{np(str)} + {or}
uspokoić się: perf: subj{np(str)} + {cp(że)}
uspokoić się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
uspołecznić: perf: subj{np(str)} + obj{np(str)}
uspołecznić się: perf: subj{np(str)}
usprawiedliwiać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
usprawiedliwiać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
usprawiedliwiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwiać: imperf: subj{np(str)} + obj{np(str)} + {or}
usprawiedliwiać się: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
usprawiedliwiać się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
usprawiedliwiać się: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwiać się: imperf: subj{np(str)} + {np(dat)} + {or}
usprawiedliwiać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwiać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
usprawiedliwiać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
usprawiedliwiać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
usprawiedliwić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(z,gen)}
usprawiedliwić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(inst)}
usprawiedliwić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwić: perf: subj{np(str)} + obj{np(str)} + {or}
usprawiedliwić się: perf: subj{np(str)} + {np(dat)} + {cp(int)}
usprawiedliwić się: perf: subj{np(str)} + {np(dat)} + {cp(że)}
usprawiedliwić się: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwić się: perf: subj{np(str)} + {np(dat)} + {or}
usprawiedliwić się: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
usprawiedliwić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(int)}
usprawiedliwić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
usprawiedliwić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
ustać: perf: subj{np(str)} + obj{np(str)}
ustać: perf: subj{np(str)} + {prepnp(w,loc)}
ustać się: perf: subj{np(str)}
ustalić: perf: subj{np(str)} + {cp(int); cp(że)}
ustalić: perf: subj{np(str)} + {cp(żeby2)}
ustalić: perf: subj{np(str)} + obj{np(str); ncp(str,int)}
ustawać: imperf: subj{np(str)} + obj{np(str)}
ustawać: imperf: subj{np(str)} + {prepnp(w,loc)}
ustąpić: perf: subj{np(str)} + {np(dat)} + {np(gen)}
ustąpić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)}
ustąpić: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
ustąpić: perf: subj{np(str)} + {prepnp(od,gen)}
ustąpić: perf: subj{np(str)} + {prepnp(przed,inst)}
ustąpić: perf: subj{np(str)} + {prepnp(z,gen)}
ustępować: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
ustępować: imperf: subj{np(str)} + {np(dat)} + {np(inst); prepnp(w,loc); prepncp(w,loc,że); advp(misc); preplexnp(pod,inst,sg,'wzgląd',atr)}
ustępować: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
ustępować: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
ustępować: imperf: subj{np(str)} + {prepnp(od,gen)}
ustępować: imperf: subj{np(str)} + {prepnp(przed,inst)}
ustępować: imperf: subj{np(str)} + {prepnp(z,gen)}
uszkodzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
uszkodzić się: perf: subj{np(str)} + {np(dat)}
uściślać: imperf: subj{np(str)} + obj{cp(int)}
uściślać: imperf: subj{np(str)} + obj{cp(że)}
uściślać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
uściślać: imperf: subj{np(str)} + {or}
uściślać się: imperf: subj{np(str)}
uściślić: perf: subj{np(str)} + obj{cp(int)}
uściślić: perf: subj{np(str)} + obj{cp(że)}
uściślić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
uściślić: perf: subj{np(str)} + {or}
uściślić się: perf: subj{np(str)}
uśmiechać się: imperf: subj,controllee{infp(_)} + controller{np(dat)}
uśmiechać się: imperf: subj{cp(żeby)} + {np(dat)}
uśmiechać się: imperf: subj{np(str)} + {cp(że)}
uśmiechać się: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
uśmiechać się: imperf: subj{np(str)} + {or}
uśmiechać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uśmiechać się: imperf: subj{np(str)} + {prepnp(na,acc)}
uśmiechnąć się: perf: subj{np(str)} + {cp(że)}
uśmiechnąć się: perf: subj{np(str)} + {or}
uśmiechnąć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
uśmiechnąć się: perf: subj{np(str)} + {prepnp(na,acc)}
uświadamiać: imperf: subj{np(str)} + {np(dat)} + {or}
uświadamiać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uświadamiać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uświadamiać: imperf: subj{np(str)} + obj{np(str)} + {cp(int); cp(że)}
uświadamiać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uświadamiać: imperf: subj{np(str)} + obj{np(str)} + {or}
uświadamiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
uświadomić: perf: subj{np(str)} + {np(dat)} + {or}
uświadomić: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
uświadomić: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w kwestii)}
uświadomić: perf: subj{np(str)} + obj{np(str)} + {cp(int); cp(że)}
uświadomić: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
uświadomić: perf: subj{np(str)} + obj{np(str)} + {or}
uświadomić: perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
utonąć: perf: subj{np(str)} + {prepnp(w,loc)}
utopić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utopić się: perf: subj{np(str)} + {prepnp(w,loc)}
utożsamiać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
utożsamiać się: imperf: subj{np(str)} + {prepnp(z,inst)}
utrwalić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {cp(że)}
utrwalić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(w,loc)}
utrwalić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
utrwalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
utrwalić: perf: subj{np(str)} + {prepnp(na,loc)} + {cp(int)}
utrwalić: perf: subj{np(str)} + {prepnp(na,loc)} + {cp(jak)}
utrwalić się: perf: subj{cp(int)} + {np(dat)} + {prepnp(w,loc)}
utrwalić się: perf: subj{cp(że)} + {np(dat)} + {prepnp(w,loc)}
utrwalić się: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
utrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
utrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
utrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
utrzymać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utrzymać: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
utrzymać się: perf: subj{np(str)} + {prepnp(przy,loc)}
utrzymać się: perf: subj{np(str)} + {xp(locat)}
utrzymywać: imperf: subj{np(str)} + {cp(jakoby)}
utrzymywać: imperf: subj{np(str)} + {cp(że)}
utrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
utrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
utrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
utrzymywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
utrzymywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
utrzymywać: imperf: subj{np(str)} + {or}
utrzymywać: imperf: subj{np(str)} + {prepnp(z,gen)} + {refl}
utrzymywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
utrzymywać się: imperf: subj{np(str)} + {prepnp(przy,loc)}
utrzymywać się: imperf: subj{np(str)} + {xp(locat)}
utwierdzać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {cp(że)}
utwierdzać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzać się: imperf: subj{np(str)} + {cp(int)}
utwierdzać się: imperf: subj{np(str)} + {cp(że)}
utwierdzać się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {cp(że)}
utwierdzić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc); prepncp(w,loc,że)}
utwierdzić się: perf: subj{np(str)} + {cp(int)}
utwierdzić się: perf: subj{np(str)} + {cp(że)}
utwierdzić się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
utyć: perf: subj{np(str)} + {comprepnp(z powodu)}
utyć: perf: subj{np(str)} + {np(str)}
utyć: perf: subj{np(str)} + {prepnp(na,loc)}
utyć: perf: subj{np(str)} + {prepnp(o,acc)}
utyć: perf: subj{np(str)} + {prepnp(od,gen)}
utyć: perf: subj{np(str)} + {prepnp(z,gen)}
uważać: imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uważać: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uważać: imperf: subj{np(str)} + {comprepnp(na temat)} + {nonch}
uważać: imperf: subj{np(str)} + controller{infp(_)} + controllee{prepadjp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepnp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
uważać: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepadjp(za,acc)}
uważać: imperf: subj{np(str)} + obj{cp(że)}
uważać: imperf: subj{np(str)} + {or}
uważać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(czy)}
uważać: imperf: subj{np(str)} + {prepnp(na,acc); cp(żeby); prepncp(na,acc,int); prepncp(na,acc,żeby)}
uważać: imperf: subj{np(str)} + {prepnp(o,loc)} + {advp(pron)}
uważać: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)} + {nonch}
uwielbiać: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
uwielbiać: imperf: subj{np(str)} + obj{np(str); cp(gdy); cp(jak); cp(kiedy); ncp(str,że)} + {prepnp(w,loc)}
uwielbiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
uwierzyć: perf: subj{np(str)} + {np(dat)} + {cp(gdy)}
uwierzyć: perf: subj{np(str)} + {np(dat)} + {cp(kiedy)}
uwierzyć: perf: subj{np(str)} + {np(dat)} + {cp(żeby2)}
uwierzyć: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'słowa',natr)}
uwierzyć: perf: subj{np(str)} + {np(dat); prepnp(w,acc)}
uwierzyć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc); cp(że); prepncp(w,acc,że); prepncp(w,acc,żeby2)}
uwłaszczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
uwłaszczyć się: perf: subj{np(str)} + {prepnp(na,loc)}
uwolnić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
uwolnić: perf: subj{np(str)} + {np(inst)} + {prepnp(spod,gen)} + {refl}
uwolnić: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uwolnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
uwolnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spod,gen)}
uwolnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uwolnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
uwolnić się: perf: subj{np(str)} + {prepnp(do,gen)}
uwzględniać: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,inst)}
uwzględnić: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,inst)}
uwziąć się: perf: subj,controller{np(str)} + controllee{infp(_)}
uwziąć się: perf: subj{np(str)} + {cp(że)}
uwziąć się: perf: subj{np(str)} + {cp(żeby)}
uwziąć się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
uzależniać: imperf: subj{np(str)} + obj{np(str); ncp(str,int)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzależniać: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int)} + {cp(int)}
uzależniać się: imperf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzależnić: perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzależnić: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int)} + {cp(int)}
uzależnić się: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,int); prepncp(od,gen,że); prepncp(od,gen,żeby)}
uzbrajać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
uzbrajać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
uzbroić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
uzbroić: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
uzdrawiać: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uzdrawiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uzdrowić: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
uzdrowić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
uzgadniać: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(z,inst)}
uzgadniać: imperf: subj{np(str)} + obj{ncp(str,int)} + {prepnp(z,inst)}
uzgadniać: imperf: subj{np(str)} + obj{np(str); cp(int)} + {prepnp(z,inst)}
uzgadniać: imperf: subj{np(str)} + {prepnp(z,inst)} + {ncp(str,że)}
uzgodnić: perf: subj{np(str)} + obj{cp(że)} + {prepnp(z,inst)}
uzgodnić: perf: subj{np(str)} + obj{ncp(str,że)} + {prepnp(z,inst)}
uzgodnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
uzgodnić: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
uzgodnić: perf: subj{np(str)} + {prepnp(z,inst)} + {ncp(str,int)}
uznać: perf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
uznać: perf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{adjp(inst)}
uznać: perf: subj,controller{np(str)} + controllee,controller2{infp(_)} + controllee2{prepadjp(za,acc)}
uznać: perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
uznać: perf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uznać: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
uznać: perf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uznać: perf: subj{np(str)} + controller{cp(że)} + controllee{prepadjp(za,acc)}
uznać: perf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(za,acc)}
uznać: perf: subj{np(str)} + {cp(int)}
uznać: perf: subj{np(str)} + {cp(żeby)}
uznać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uznać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uznać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
uznać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
uznać: perf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepnp(za,acc)}
uznać: perf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
uznać: perf: subj{np(str)} + obj{cp(że)}
uznawać: imperf: subj,controller{np(str)} + controllee{adjp(inst)} + {refl}
uznawać: imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
uznawać: imperf: subj,controller{np(str)} + controllee{prepadjp(za,acc)} + {refl}
uznawać: imperf: subj,controller{np(str)} + controllee{prepnp(za,acc)} + {refl}
uznawać: imperf: subj,controller{np(str)} + obj,controllee,controller2{infp(_)} + controllee2{prepnp(za,acc)}
uznawać: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepadjp(jako,str)}
uznawać: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(jako,str)}
uznawać: imperf: subj{np(str)} + controller{cp(że)} + controllee{prepnp(za,acc)}
uznawać: imperf: subj{np(str)} + {cp(int)}
uznawać: imperf: subj{np(str)} + {cp(żeby)}
uznawać: imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{prepadjp(za,acc)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,int); ncp(str,że)} + controllee{prepnp(za,acc)}
uznawać: imperf: subj{np(str)} + obj,controller{np(str); ncp(str,że)} + controllee{prepadjp(za,acc)}
uznawać: imperf: subj{np(str)} + obj{cp(że)}
uzupełnić: perf: subj{np(str)} + {cp(że)}
uzupełnić: perf: subj{np(str)} + obj{np(str)} + {ncp(inst,że)}
uzupełnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
uzupełnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
uzupełnić: perf: subj{np(str)} + {or}
uzyskać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
uzyskiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
użyć: perf: subj{np(str)} + obj,controller{np(gen)} + controllee{prepnp(jako,str)}
użyć: perf: subj{np(str)} + obj{np(gen)} + {prepncp(do,gen,żeby)}
użyć: perf: subj{np(str)} + obj{np(gen)} + {prepnp(dla,gen)}
użyć: perf: subj{np(str)} + obj{np(gen)} + {prepnp(do,gen)}
użyć: perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
użytkować: imperf: subj{np(str)} + obj{np(str)}
używać: imperf: subj{np(str)} + obj,controller{np(gen)} + controllee{prepnp(jako,str)}
używać: imperf: subj{np(str)} + obj{np(gen)} + {prepncp(do,gen,żeby)}
używać: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(dla,gen)}
używać: imperf: subj{np(str)} + obj{np(gen)} + {prepnp(do,gen)}
używać: imperf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(dat,_,'siebie',natr)}
wahać: imperf: subj{np(str)} + {np(inst)}
wahać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
wahać się: imperf: subj{np(str)} + {cp(int)}
wahać się: imperf: subj{np(str)} + {cp(żeby)}
wahać się: imperf: subj{np(str)} + {prepncp(nad,inst,żeby)}
wahać się: imperf: subj{np(str)} + {prepncp(przed,inst,żeby2)}
wahać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wahać się: imperf: subj{np(str)} + {prepnp(między,inst)}
wahać się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
wahać się: imperf: subj{np(str)} + {prepnp(przed,inst)}
walczyć: imperf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat); prepnp(z,inst)}
walczyć: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)}
walczyć: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)} + {prepnp(przeciw,dat); prepnp(z,inst)}
walczyć: imperf: subj{np(str)} + {prepnp(pod,inst)} + {prepnp(przeciw,dat); prepnp(z,inst)}
walczyć: imperf: subj{np(str)} + {prepnp(w,loc)}
walczyć: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc); prepncp(za,acc,żeby)}
walić: imperf: {np(dat)} + {np(inst)} + {xp(abl)}
walić: imperf: {np(dat)} + {xp(locat)}
walić: imperf: subj{cp(int)} + {np(str)}
walić: imperf: subj{cp(że)} + {np(str)}
walić: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
walić: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
walić: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
walić: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
walić: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
walić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,acc)} + {refl}
walić: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
walić: imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
walić: imperf: subj{np(str)} + obj{np(str)}
walić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
walić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,acc)}
walić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
walić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
walić: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
walić: imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(za,inst)}
walić: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
walić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
walić się: imperf: subj{np(str)} + {prepnp(z,inst)}
walić się: imperf: subj{np(str)} + {xp(adl)}
warto: imperf: {cp(żeby)}
warto: imperf: {infp(_)}
ważyć: imperf: subj{np(str)} + {np(inst)} + {refl}
ważyć: imperf: subj{np(str)} + {np(str)}
ważyć: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
ważyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
ważyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
ważyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
ważyć: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int); prepncp(na,loc,że)}
ważyć: imperf: subj{np(str)} + {prepnp(na,loc)} + {refl}
ważyć się: imperf: subj,controller{np(str)} + controllee{infp(_)}
ważyć się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
ważyć się: imperf: subj{np(str)} + {prepnp(na,loc)}
wąchać: imperf: subj{np(str)} + {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)} + {np(inst)} + {prepnp(pod,acc)} + {refl}
wbić: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wbić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,acc)}
wbić się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc); prepnp(w,acc)}
wbić się: perf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
wbijać: imperf: subj{np(str)} + {cp(żeby)}
wbijać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wbijać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wbijać: imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)} + {refl}
wbijać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wbijać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepnp(na,acc)}
wbijać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(pod,acc)}
wbijać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wbudować: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wbudować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wchłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wchłaniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wchłaniać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchłaniać się: imperf: subj{np(str)} + {prepnp(w,acc)}
wchłaniać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchłaniać się: imperf: subj{np(str)} + {xp(locat)}
wchłonąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wchłonąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wchłonąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchłonąć się: perf: subj{np(str)} + {prepnp(w,acc)}
wchłonąć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wchłonąć się: perf: subj{np(str)} + {xp(locat)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wchodzić: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wchodzić: imperf: subj{np(str)} + {xp(perl)}
wchodzić: imperf: subj{np(str)} + {xp(temp)} + {preplexnp(w,acc,sg,'życie',natr)}
wciągać: imperf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
wciągać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
wciągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wciągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wciągać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wciągać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wciągać się: imperf: subj{np(str)} + {prepnp(w,acc)}
wciągnąć: perf: subj{np(str)} + {np(inst)} + {xp(adl)} + {refl}
wciągnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc)}
wciągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wciągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wciągnąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wciągnąć się: perf: subj{np(str)} + {prepnp(do,gen)}
wciągnąć się: perf: subj{np(str)} + {prepnp(w,acc)}
wcielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wcielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wcielać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wcielać się: imperf: subj{np(str)} + {prepnp(w,acc)}
wcielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wcielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wcielić się: perf: subj{np(str)} + {prepnp(do,gen)}
wcielić się: perf: subj{np(str)} + {prepnp(w,acc)}
wdać się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wdawać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wdrażać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wdrażać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wdrażać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wdrażać się: imperf: subj{np(str)} + {prepnp(w,acc)}
wdrożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wdrożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wdrożyć się: perf: subj{np(str)} + {prepnp(do,gen)}
wdrożyć się: perf: subj{np(str)} + {prepnp(w,acc)}
wdychać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wdychać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wdychać: imperf: subj{np(str)} + obj{np(str)} + {xp(perl)}
wdzierać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(perl)}
wdzierać się: imperf: subj{np(str)} + {prepnp(w,acc)}
wdzierać się: imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
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)}
weryfikować: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
weryfikować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
weryfikować: imperf: subj{np(str)} + obj{cp(int)}
weryfikować: imperf: subj{np(str)} + obj{cp(że)}
weryfikować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wesprzeć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wesprzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wesprzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wesprzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wesprzeć się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wesprzeć się: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
westchnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
westchnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
westchnąć: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wetować: imperf: subj{np(str)} + {np(inst)} + {np(str)} + {lexnp(dat,_,'siebie',natr)}
wetować: imperf: subj{np(str)} + obj{np(str)}
wędrować: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
wędrować: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
wędrować: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wędrować: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wędrować: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wędrować: imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(adl)}
wędrować: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wiać: imperf: {np(inst)} + {prepnp(na,acc)}
wiać: imperf: {np(inst)} + {prepnp(od,gen)}
wiać: imperf: {np(inst)} + {xp(abl)}
wiać: imperf: {np(inst)} + {xp(adl)}
wiać: imperf: {np(inst)} + {xp(perl)}
wiać: imperf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
wiać: imperf: subj{np(str)} + obj{np(str)}
wiać: imperf: subj{np(str)} + {prepnp(do,gen)}
wiać: imperf: subj{np(str)} + {prepnp(na,acc)}
wiać: imperf: subj{np(str)} + {prepnp(przed,inst)} + {xp(adl)}
wiać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wiać: imperf: subj{np(str)} + {xp(perl)}
wiadomo: imperf: {np(dat)} + {comprepnp(w kwestii)} + {nonch}
wiadomo: imperf: {np(dat)} + {comprepnp(w sprawie)} + {nonch}
wiadomo: imperf: {np(dat)} + {cp(jakoby); cp(żeby)} + {nonch}
wiadomo: imperf: {np(dat)} + {prepncp(o,loc,jakoby)} + {nonch}
wiadomo: imperf: {np(dat)} + {prepnp(o,loc); comprepnp(na temat); cp(int); cp(że); prepncp(o,loc,int); prepncp(o,loc,że); prepncp(o,loc,żeby)} + {nonch}
wiadomo: imperf: {prepnp(z,inst)} + {nonch} + {fixed('nigdy')}
wiązać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wiązać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wiązać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wiązać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wiązać się: imperf: subj{np(str)} + {np(inst)}
wiązać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wiązać się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
widać: imperf: {cp(jak); cp(że)}
widać: imperf: {np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int)}
widać: imperf: {np(str)} + {prepnp(z,gen)}
widać: imperf: {np(str)} + {xp(locat)}
widać: imperf: {prepnp(po,loc)} + {cp(int)}
widać: imperf: {prepnp(po,loc)} + {cp(żeby2)}
widać: imperf: {prepnp(po,loc); prepncp(po,loc,int)} + {cp(że)}
widać: imperf: {prepnp(z,gen)} + {cp(int)}
widać: imperf: {prepnp(z,gen)} + {cp(że)}
widnieć: imperf: subj{E}
widnieć: imperf: subj{np(str)} + {prepnp(na,loc)}
widnieć: imperf: subj{np(str)} + {xp(locat)}
widzieć: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {refl}
widzieć: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {refl}
widzieć: imperf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)}
widzieć: imperf: subj{np(str)} + controller{np(str)} + controllee{np(inst)}
widzieć: imperf: subj{np(str)} + {cp(gdy)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + {cp(int)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + {cp(jakoby)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + {cp(jak)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + {cp(kiedy)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + {infp(_)} + {lexnp(str,sg,'potrzeba',atr)}
widzieć: imperf: subj{np(str)} + {infp(_)} + {lexnp(str,sg,'powód',atr)}
widzieć: imperf: subj{np(str)} + {infp(_)} + {lexnp(str,sg,'problem',atr)}
widzieć: imperf: subj{np(str)} + {infp(_)} + {lexnp(str,sg,'sens',atr)}
widzieć: imperf: subj{np(str)} + {lexnp(inst,pl,'oko',ratr)} + {refl}
widzieć: imperf: subj{np(str)} + {np(str); cp(int); cp(jak); cp(że); cp(żeby2); ncp(str,int); ncp(str,jak); ncp(str,że)}
widzieć: imperf: subj{np(str)} + {np(str); ncp(str,że)} + {preplexnp(na,acc,pl,'oko',batr)}
widzieć: imperf: subj{np(str)} + obj,controller{cp(żeby)} + controllee{xp(mod)}
widzieć: imperf: subj{np(str)} + obj,controller{cp(że)} + controllee{xp(mod)}
widzieć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
widzieć: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
widzieć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
widzieć: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
widzieć: imperf: subj{np(str)} + {xp(locat)} + {refl}
widzieć się: imperf: controller{np(dat)} + controllee{infp(_)}
widzieć się: imperf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
widzieć się: imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
widzieć się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
widzieć się: imperf: subj{cp(jakoby)} + {np(dat)}
widzieć się: imperf: subj{cp(żeby)} + {np(dat)}
widzieć się: imperf: subj{cp(że)} + {np(dat)}
widzieć się: imperf: subj{np(str)} + {np(dat)}
widzieć się: imperf: subj{np(str)} + {prepnp(z,inst)}
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: controller{np(dat)} + controllee{xp(mod)} + {prepnp(w,loc)}
wietrzyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wietrzyć się: imperf: subj{np(str)} + {xp(locat)}
winić: imperf: subj{np(str)} + {cp(że)} + {refl}
winić: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
winić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
winić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
winić: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)} + {refl}
winić: imperf: subj{np(str)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)} + {refl}
winien: imperf: subj,controller{E} + controllee{infp(_)}
wirować: imperf: {np(dat)} + {xp(locat)}
wirować: imperf: subj{np(str)} + {np(dat)} + {prepnp(wokół,gen)}
wirować: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wirować: imperf: subj{np(str)} + {np(inst)}
wirować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wirować: imperf: subj{np(str)} + {prepnp(na,loc)}
wirować: imperf: subj{np(str)} + {prepnp(za,inst)}
wirować: imperf: subj{np(str)} + {xp(adl)}
wisieć: imperf: subj{cp(int)} + {np(dat)} + {np(inst)}
wisieć: imperf: subj{cp(że)} + {np(dat)} + {np(inst)}
wisieć: imperf: subj{cp(że)} + {prepnp(nad,inst)}
wisieć: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
wisieć: imperf: subj{np(str); ncp(str,że)} + {prepnp(nad,inst)}
wisieć: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
wisieć: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wisieć: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wisieć: imperf: subj{np(str)} + {preplexnp(u,gen,sg,'klamka',ratr)}
wisieć: imperf: subj{np(str)} + {preplexnp(w,loc,sg,'powietrze',atr)}
wisieć: imperf: subj{np(str)} + {preplexnp(w,loc,sg,'próżnia',atr)}
wisieć: imperf: subj{np(str)} + {prepnp(na,loc)}
wisieć: imperf: subj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wisieć: imperf: subj{np(str)} + {prepnp(przy,loc)}
witać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
witać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
witać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
witać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
wizytować: imperf: subj{np(str)} + obj{np(str)}
wkraczać: imperf: subj{np(str)} + {prepnp(do,gen)}
wkraczać: imperf: subj{np(str)} + {prepnp(na,acc)}
wkraczać: imperf: subj{np(str)} + {prepnp(w,acc)}
wkraczać: imperf: subj{np(str)} + {xp(adl)}
wkroczyć: perf: subj{np(str)} + {prepnp(do,gen)}
wkroczyć: perf: subj{np(str)} + {prepnp(na,acc)}
wkroczyć: perf: subj{np(str)} + {prepnp(w,acc)}
wkroczyć: perf: subj{np(str)} + {xp(adl)}
włamać się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
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)}
włóczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
włóczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(za,acc)}
włóczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
włóczyć: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,inst)}
włóczyć: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
włóczyć się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
włóczyć się: imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
włóczyć się: imperf: subj{np(str)} + {prepnp(za,inst)}
włóczyć się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wmawiać: imperf: subj{np(str)} + {np(dat)} + {or}
wmawiać: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wmawiać: imperf: subj{np(str)} + obj{cp(int)} + {prepnp(w,acc)}
wmawiać: imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wmawiać: imperf: subj{np(str)} + obj{cp(żeby)} + {prepnp(w,acc)}
wmawiać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wmawiać: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(w,acc)}
wmawiać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
wmawiać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,acc)}
wmawiać: imperf: subj{np(str)} + {prepnp(w,acc)} + {or}
wmówić: perf: subj{np(str)} + {np(dat)} + {or}
wmówić: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wmówić: perf: subj{np(str)} + obj{cp(int)} + {prepnp(w,acc)}
wmówić: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
wmówić: perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(w,acc)}
wmówić: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wmówić: perf: subj{np(str)} + obj{cp(że)} + {prepnp(w,acc)}
wmówić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)}
wmówić: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(w,acc)}
wmówić: perf: subj{np(str)} + {prepnp(w,acc)} + {or}
wnioskować: imperf: subj{np(str)} + {comprepnp(na temat)}
wnioskować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wnioskować: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wnioskować: imperf: subj{np(str)} + {or}
wnioskować: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
wnioskować: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wnioskować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
wnioskować: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wnioskować: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wnioskować: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wnioskować: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wnioskować: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wnioskować: imperf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(żeby2)}
wnioskować: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,żeby)}
wnioskować: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wnioskować: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wnioskować: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wnioskować: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(żeby2)}
wnosić: imperf: subj{np(str)} + {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)}
wodzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(po,loc)}
wodzić: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,inst)}
wodzić: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'pokuszenie',natr)}
wodzić: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(za,acc,sg,'nos',natr)}
wodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wodzić się: imperf: subj{np(str)} + {prepnp(po,loc)} + {prepnp(z,inst)}
wodzić się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepnp(za,acc)}
woleć: imperf: subj,controller{np(str)} + controllee{infp(_)}
woleć: imperf: subj{np(str)} + controller{np(str)} + controllee{prepnp(niż,str)}
woleć: imperf: subj{np(str)} + {cp(gdy)}
woleć: imperf: subj{np(str)} + {cp(jak)}
woleć: imperf: subj{np(str)} + {cp(jeśli)}
woleć: imperf: subj{np(str)} + {cp(kiedy)}
woleć: imperf: subj{np(str)} + {cp(żeby)}
woleć: imperf: subj{np(str)} + {np(str)} + {prepnp(od,gen)}
wolno: imperf: controller{np(dat)} + controllee{infp(_)}
wolno: imperf: {cp(żeby)}
wolno: imperf: {np(dat)} + {advp(pron)}
wolno: imperf: {np(dat)} + {np(str)}
wołać: imperf: subj{np(str)} + controller{prepnp(na,acc)} + controllee{np(inst)}
wołać: imperf: subj{np(str)} + controller{prepnp(za,inst)} + controllee{np(nom)}
wołać: imperf: subj{np(str)} + {infp(_)}
wołać: imperf: subj{np(str)} + {np(gen)}
wołać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
wołać: imperf: subj{np(str)} + obj,controller{prepnp(na,acc)} + controllee{np(nom)}
wołać: imperf: subj{np(str)} + {or}
wołać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wołać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że); cp(żeby)}
wołać: imperf: subj{np(str)} + {prepnp(na,acc)}
wołać: imperf: subj{np(str)} + {prepnp(o,acc)}
wołać: imperf: subj{np(str)} + {prepnp(za,inst)} + {cp(żeby)}
wpadać: imperf: subj{cp(żeby)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: imperf: subj{cp(że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: imperf: subj{infp(_)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: imperf: subj{np(str)} + {cp(int)}
wpadać: imperf: subj{np(str)} + {cp(że)}
wpadać: imperf: subj{np(str)} + {cp(żeby)}
wpadać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',atr)}
wpadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(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)}
wprawiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprawiać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprawiać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wprawiać się: imperf: subj{np(str)} + {prepnp(w,loc)}
wprawić: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wprawić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(w,acc)}
wprawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprawić się: perf: subj{np(str)} + {prepnp(do,gen)}
wprawić się: perf: subj{np(str)} + {prepnp(w,acc)}
wprawić się: perf: subj{np(str)} + {prepnp(w,loc)}
wprowadzać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprowadzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprowadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wprowadzać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wprowadzać się: imperf: subj{np(str)} + {xp(adl)}
wprowadzić: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
wprowadzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wprowadzić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wprowadzić się: perf: subj{np(str)} + {prepnp(do,gen)}
wprowadzić się: perf: subj{np(str)} + {xp(adl)}
wpuszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpuszczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
wpuścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wpuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wpuścić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,że)}
wracać: imperf: subj{np(str)} + {np(dat)} + {np(str)}
wracać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); xp(adl)}
wracać: imperf: subj{np(str)} + {prepnp(na,acc)}
wracać: imperf: subj{np(str)} + {prepnp(od,gen)}
wracać: imperf: subj{np(str)} + {prepnp(po,acc)}
wracać: imperf: subj{np(str)} + {prepnp(z,gen)}
wracać: imperf: subj{np(str)} + {xp(abl)}
wracać: imperf: subj{np(str)} + {xp(temp)}
wracać się: imperf: subj{np(str)} + {np(dat)}
wracać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wracać się: imperf: subj{np(str)} + {prepnp(po,acc)}
wracać się: imperf: subj{np(str)} + {xp(abl)}
wracać się: imperf: subj{np(str)} + {xp(adl)}
wręczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepncp(za,acc,żeby)}
wręczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
wręczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
wrócić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wrócić: perf: subj{np(str)} + {preplexnp(na,loc,sg,'tarcza',natr); preplexnp(z,inst,sg,'tarcza',natr)}
wrócić: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(do,gen,żeby); xp(adl)}
wrócić: perf: subj{np(str)} + {prepnp(na,acc)}
wrócić: perf: subj{np(str)} + {prepnp(od,gen)}
wrócić: perf: subj{np(str)} + {prepnp(po,acc)}
wrócić: perf: subj{np(str)} + {prepnp(z,gen)}
wrócić: perf: subj{np(str)} + {xp(abl)}
wrócić: perf: subj{np(str)} + {xp(adl)}
wrócić: perf: subj{np(str)} + {xp(temp)}
wrócić się: perf: subj{np(str)} + {np(dat)}
wrócić się: perf: subj{np(str)} + {prepnp(do,gen)}
wrócić się: perf: subj{np(str)} + {prepnp(po,acc)}
wrócić się: perf: subj{np(str)} + {xp(abl)}
wrócić się: perf: subj{np(str)} + {xp(adl)}
wróżyć: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {advp(misc)}
wróżyć: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)} + {cp(że)}
wróżyć: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(z,gen)}
wróżyć: imperf: subj{np(str)} + {or}
wróżyć: imperf: subj{np(str)} + {preplexnp(na,acc,sg,'dwoje',natr)}
wróżyć: imperf: subj{np(str)} + {prepnp(na,loc)}
wrzucać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wrzucać: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(inst,sg,'łopata',natr)} + {preplexnp(do,gen,sg,'głowa',natr)}
wrzucać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,sg,'łopata',natr)} + {preplexnp(do,gen,sg,'głowa',natr)}
wrzucać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wrzucać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'siebie',natr)}
wrzucać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wrzucić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wrzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wrzucić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,acc,sg,'siebie',natr)}
wsadzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wsadzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wsadzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wsadzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wsadzić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wsiadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wsiadać: imperf: subj{np(str)} + {prepnp(do,gen)}
wsiadać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wsiadać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wsiadać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {or}
wsiadać: imperf: subj{np(str)} + {prepnp(w,acc)}
wsiąść: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wsiąść: perf: subj{np(str)} + {prepnp(do,gen)}
wsiąść: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wsiąść: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wsiąść: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wsiąść: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {or}
wsiąść: perf: subj{np(str)} + {prepnp(w,acc)}
wskazać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
wskazać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
wskazać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wskazać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wskazać: perf: subj{np(str)} + obj{np(str); cp(że)} + {np(dat)} + {np(inst)}
wskazywać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(int)}
wskazywać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(żeby)}
wskazywać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,acc); cp(że); prepncp(na,acc,int); prepncp(na,acc,że)}
wskazywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wskazywać: imperf: subj{np(str)} + obj{np(str); cp(że)} + {np(dat)} + {np(inst)}
wskoczyć: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'głowa',natr)}
wskoczyć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
wskoczyć: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wskoczyć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wsłuchiwać się: imperf: subj{np(str)} + {prepnp(w,acc); prepncp(w,acc,int)}
wspierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wspierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wspierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wspierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wspierać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
wspierać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
wspierać się: imperf: subj{np(str)} + {prepnp(w,loc)}
wspinać się: imperf: subj{np(str)} + {prepnp(po,loc)} + {xp(adl)}
wspomagać: imperf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)} + {refl}
wspomagać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {refl}
wspomagać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wspomagać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wspominać: imperf: subj{np(str)} + {np(dat)} + {or}
wspominać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
wspominać: imperf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wspominać: imperf: subj{np(str)} + obj{cp(jak)}
wspominać: imperf: subj{np(str)} + obj{cp(żeby2)}
wspominać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wspominać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
wspomnieć: perf: subj{np(str)} + {np(dat)} + {or}
wspomnieć: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,jak); prepncp(o,loc,że)}
wspomnieć: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wspomnieć: perf: subj{np(str)} + obj{cp(jak)}
wspomnieć: perf: subj{np(str)} + obj{cp(żeby2)}
wspomnieć: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wspomnieć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)}
wspomóc: perf: subj{np(str)} + {np(inst)} + {prepnp(przy,loc)} + {refl}
wspomóc: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)} + {refl}
wspomóc: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przy,loc)}
wspomóc: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
współczuć: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
współczuć: imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,int); ncp(gen,że)}
współczuć: imperf: subj{np(str)} + {prepnp(z,inst)}
współdziałać: imperf: subj{np(str)} + {prepnp(przy,loc)} + {prepnp(z,inst)}
współdziałać: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
współpracować: imperf: subj{np(str)} + {prepnp(przy,loc); prepnp(w,loc); xp(locat)} + {prepnp(z,inst)}
współpracować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na rzecz)}
współpracować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w kwestii)}
współpracować: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
wstawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wstawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wstawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wstawiać się: imperf: subj{np(str)} + {np(inst)}
wstawiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,inst)}
wstawiać się: imperf: subj{np(str)} + {prepnp(po,loc)}
wstawiać się: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(za,inst)}
wstawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(do,gen)}
wstawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
wstawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wstawić się: perf: subj{np(str)} + {np(inst)}
wstawić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(za,inst)}
wstawić się: perf: subj{np(str)} + {prepnp(po,loc)}
wstawić się: perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(za,inst)}
wstąpić: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(na,acc); prepnp(po,acc)}
wstąpić: perf: subj{np(str)} + {prepnp(w,acc)}
wstępować: imperf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(na,acc); prepnp(po,acc)}
wstępować: imperf: subj{np(str)} + {prepnp(w,acc)}
wstyd: imperf: controller{np(dat)} + controllee{infp(_)}
wstyd: imperf: {np(dat)} + {cp(int)}
wstyd: imperf: {np(dat)} + {cp(że)}
wstyd: imperf: {np(dat)} + {cp(żeby)}
wstyd: imperf: {np(dat)} + {np(gen)}
wstyd: imperf: {np(dat)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wstydzić się: imperf: subj,controller{np(str)} + controllee{infp(_)}
wstydzić się: imperf: subj{np(str)} + {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)}
wściec: perf: subj{cp(że)} + {np(str)}
wściec: perf: subj{np(str); ncp(str,że)} + {np(str)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(gdy)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(jak)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(kiedy)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
wściec się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,int); prepncp(za,acc,że)}
wtargnąć: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wtórować: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wtórować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
wtrącać: imperf: subj{np(str)} + obj{cp(że)}
wtrącać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wtrącać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wtrącać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wtrącać się: imperf: subj{np(str)} + {cp(że)}
wtrącać się: imperf: subj{np(str)} + {or}
wtrącać się: imperf: subj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(w,acc,int); prepncp(w,acc,że)}
wtrącić: perf: subj{np(str)} + obj{cp(że)}
wtrącić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wtrącić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wtrącić: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wtrącić się: perf: subj{np(str)} + {cp(że)}
wtrącić się: perf: subj{np(str)} + {or}
wtrącić się: perf: subj{np(str)} + {prepnp(do,gen); prepnp(w,acc); prepncp(do,gen,int); prepncp(do,gen,że); prepncp(w,acc,int); prepncp(w,acc,że)}
wybaczać: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
wybaczać: imperf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wybaczać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wybaczyć: perf: subj{np(str)} + {np(dat)} + {prepnp(za,acc); prepncp(za,acc,że)}
wybaczyć: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wybaczyć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,jak); ncp(str,że)} + {np(dat)}
wybić: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(z,gen,_,'głowa',atr)}
wybić: perf: subj{np(str)} + {np(dat)} + {xp(perl)}
wybić: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {preplexnp(z,gen,_,'głowa',atr)}
wybić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wybić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wybić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pień',natr)}
wybić: perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
wybić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wybić: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wybić: perf: subj{np(str)} + {prepnp(w,loc)} + {or}
wybić się: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wybić się: perf: subj{np(str)} + {prepnp(na,acc)}
wybić się: perf: subj{np(str)} + {prepnp(na,loc)}
wybić się: perf: subj{np(str)} + {prepnp(ponad,acc)}
wybić się: perf: subj{np(str)} + {prepnp(w,loc)}
wybić się: perf: subj{np(str)} + {prepnp(z,gen)}
wybić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wybiec: perf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
wybiec: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wybiec: perf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wybiec: perf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'myśl',natr)}
wybiegać: imperf: subj,controller{np(str)} + controllee{infp(_)} + {xp(abl)} + {xp(adl)}
wybiegać: imperf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wybiegać: imperf: subj{np(str)} + {prepnp(za,inst)} + {xp(abl)} + {xp(adl)}
wybiegać: imperf: subj{np(str)} + {xp(adl)} + {lexnp(inst,_,'myśl',natr)}
wybiegać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wybiegać się: perf: subj{np(str)} + {xp(locat)}
wybierać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
wybierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wybierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wybierać: imperf: subj{np(str)} + {prepnp(między,inst)}
wybierać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
wybierać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wybierać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
wybierać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wybierać się: imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wybijać: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {cp(że)} + {preplexnp(z,gen,_,'głowa',atr)}
wybijać: perf: subj{np(str)} + {np(dat)} + {xp(perl)}
wybijać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {preplexnp(z,gen,_,'głowa',atr)}
wybijać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wybijać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
wybijać: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pień',natr)}
wybijać: perf: subj{np(str)} + obj{np(str)} + {prepnp(co do,gen)}
wybijać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wybijać: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)}
wybijać: perf: subj{np(str)} + {prepnp(w,loc)} + {or}
wybijać się: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
wybijać się: perf: subj{np(str)} + {prepnp(na,acc)}
wybijać się: perf: subj{np(str)} + {prepnp(na,loc)}
wybijać się: perf: subj{np(str)} + {prepnp(ponad,acc)}
wybijać się: perf: subj{np(str)} + {prepnp(w,loc)}
wybijać się: perf: subj{np(str)} + {prepnp(z,gen)}
wybijać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wybrać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
wybrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wybrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wybrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wybrać: perf: subj{np(str)} + {prepnp(między,inst)}
wybrać się: perf: subj,controller{np(str)} + controllee{infp(_)}
wybrać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wybrać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(po,acc)}
wybrać się: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wybrać się: perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wybraniać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)} + {refl}
wybraniać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
wybraniać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)} + {refl}
wybraniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wybraniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wybraniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wybronić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)} + {refl}
wybronić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
wybronić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)} + {refl}
wybronić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(od,gen)}
wybronić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wybronić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(z,gen)}
wybuchać: imperf: subj{np(str)} + {cp(że)}
wybuchać: imperf: subj{np(str)} + {np(inst)} + {or}
wybuchnąć: perf: subj{np(str)} + {cp(że)}
wybuchnąć: perf: subj{np(str)} + {np(inst)} + {or}
wycenić: perf: subj{np(str)} + {advp(misc)} + {refl}
wycenić: perf: subj{np(str)} + {cp(int)}
wycenić: perf: subj{np(str)} + {cp(że)}
wycenić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {advp(misc)}
wycenić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wycenić: perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wychodzić: imperf: {prepadjp(na,acc)}
wychodzić: imperf: {prepncp(na,acc,że)}
wychodzić: imperf: {prepnp(na,acc)}
wychodzić: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen)}
wychodzić: imperf: subj,controller{np(str); ncp(str,że)} + controllee{prepadjp(na,acc)} + {np(dat)}
wychodzić: imperf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wychodzić: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {lexnp(inst,sg,'bok',natr)}
wychodzić: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {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)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wychodzić: perf: subj{np(str)} + obj{np(str)}
wychować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wychować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wychować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wychować się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
wychować się: imperf: subj{np(str)} + {prepnp(na,loc)}
wychować się: imperf: subj{np(str)} + {xp(locat)}
wychowywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wychowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wychowywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wychowywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
wychowywać się: imperf: subj{np(str)} + {prepnp(na,loc)}
wychowywać się: imperf: subj{np(str)} + {xp(locat)}
wyciąć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)} + {np(inst)} + {xp(abl)}
wyciąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wyciąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wyciąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
wyciąć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(co do,gen,sg,'noga',natr)}
wyciąć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'noga',natr)}
wyciąć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pień',natr)}
wyciągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyciągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); xp(adl)}
wyciągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyciągać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyciągać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyciągać się: imperf: subj{np(str)} + {xp(locat)}
wyciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); xp(adl)}
wyciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyciągnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyciągnąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wyciągnąć się: perf: subj{np(str)} + {xp(locat)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(na,loc)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(co do,gen,sg,'noga',natr)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(do,gen,sg,'noga',natr)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pień',natr)}
wycinać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyciskać: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(z,gen)}
wyciskać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wyciskać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wyciskać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyciskać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyciskać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyciskać: imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wyciskać: imperf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wyciskać: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wyciskać: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wycisnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {np(str)} + {prepnp(z,gen)}
wycisnąć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wycisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wycisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wycisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wycisnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycisnąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wycisnąć: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(int)}
wycisnąć: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(że)}
wycisnąć: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(int)}
wycisnąć: perf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
wycofać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycofać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wycofać się: perf: subj{np(str)} + {prepncp(z,gen,że)}
wycofać się: perf: subj{np(str)} + {prepnp(z,gen)}
wycofać się: perf: subj{np(str)} + {xp(abl)}
wycofywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wycofywać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wycofywać się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wycofywać się: imperf: subj{np(str)} + {xp(abl)}
wyczuwać: imperf: subj{np(str)} + {np(inst)} + {cp(int)}
wyczuwać: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
wyczuwać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)}
wyczytać: perf: subj{np(str)} + obj{cp(int)} + {prepnp(z,gen)}
wyczytać: perf: subj{np(str)} + obj{cp(int)} + {xp(locat)}
wyczytać: perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(z,gen)}
wyczytać: perf: subj{np(str)} + obj{cp(żeby)} + {xp(locat)}
wyczytać: perf: subj{np(str)} + obj{cp(że)} + {comprepnp(na temat)} + {xp(locat)}
wyczytać: perf: subj{np(str)} + obj{cp(że)} + {prepnp(o,loc)} + {xp(locat)}
wyczytać: perf: subj{np(str)} + obj{cp(że)} + {prepnp(z,gen)}
wyczytać: perf: subj{np(str)} + obj{cp(że)} + {xp(locat)}
wyczytać: perf: subj{np(str)} + obj{nonch} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {xp(locat)}
wyczytać: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int)}
wyczytać: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {xp(locat)}
wyczytać: perf: subj{np(str)} + {prepnp(z,gen)} + {or}
wydać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wydać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wydać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
wydać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydać się: perf: subj,controller{E} + controllee{infp(imperf)} + {np(dat)}
wydać się: perf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
wydać się: perf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
wydać się: perf: subj{cp(int)}
wydać się: perf: subj{cp(jakby)} + {np(dat)}
wydać się: perf: subj{cp(że)} + {np(dat)}
wydać się: perf: subj{np(str)}
wydać się: perf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydarzyć się: perf: subj{cp(że)}
wydarzyć się: perf: subj{np(str)} + {np(dat)} + {xp(temp)}
wydarzyć się: perf: subj{np(str)} + {xp(locat)}
wydawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wydawać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wydawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepnp(w,loc)}
wydawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydawać się: imperf: subj,controller{cp(int)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(int)} + controllee{np(inst)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(kiedy)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(żeby)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(żeby)} + controllee{np(inst)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(że)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{cp(że)} + controllee{np(inst)} + {np(dat)}
wydawać się: imperf: subj,controller{E} + controllee{infp(imperf)} + {np(dat)}
wydawać się: imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{adjp(pred)} + {np(dat)}
wydawać się: imperf: subj,controller{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + controllee{np(inst)} + {np(dat)}
wydawać się: imperf: subj{cp(jakby)} + {np(dat)}
wydawać się: imperf: subj{cp(że)} + {np(dat)}
wydawać się: imperf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wydłużać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydłużać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydłużyć: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydłużyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wydobyć: perf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wydobyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydobyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydobyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydobyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wydobyć się: perf: subj{np(str)} + {prepnp(na,acc)}
wydobyć się: perf: subj{np(str)} + {prepnp(z,gen)}
wydobyć się: perf: subj{np(str)} + {xp(abl)}
wydobywać: imperf: subj{np(str)} + {np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wydobywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wydobywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydobywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydobywać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wydobywać się: imperf: subj{np(str)} + {prepnp(na,acc)}
wydobywać się: imperf: subj{np(str)} + {prepnp(z,gen)}
wydobywać się: imperf: subj{np(str)} + {xp(abl)}
wydostać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydostać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wydostać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wydostać się: perf: subj{np(str)} + {prepnp(z,gen)}
wydostać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wydrukować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wydrukować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wydrukować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wydzielać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
wydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
wydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)} + {prepnp(z,gen)}
wydzielać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wydzielać się: imperf: subj{np(str)} + {prepnp(z,gen)}
wydzielić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {prepnp(z,gen)}
wydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(w,loc)}
wydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)} + {prepnp(z,gen)}
wydzielić: perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wydzielić się: perf: subj{np(str)} + {prepnp(z,gen)}
wyeliminować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyglądać: imperf: {cp(że)}
wyglądać: imperf: {prepncp(na,acc,że)}
wyglądać: imperf: subj,controller{np(str)} + controllee{prepadjp(na,acc)} + {np(dat)}
wyglądać: imperf: subj,controller{np(str)} + controllee{prepnp(na,acc)} + {np(dat)}
wyglądać: imperf: subj,controller{np(str)} + controllee{xp(mod)}
wyglądać: imperf: subj{np(str)} + {np(gen)}
wyglądać: imperf: subj{np(str)} + {prepnp(na,acc)}
wyglądać: imperf: subj{np(str)} + {prepnp(przez,acc)}
wygłaszać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygłaszać: imperf: subj{np(str)} + {or}
wygłosić: imperf: subj{np(str)} + {cp(że)}
wygłosić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wygłosić: imperf: subj{np(str)} + {or}
wygrać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygrać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
wygrać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wygrać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wygrać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wygrać: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wygrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wygrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
wygrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wygrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wygrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
wygrywać: imperf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
wyjaśniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
wyjaśniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśniać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)} + {or}
wyjaśniać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśniać się: imperf: subj{cp(int)}
wyjaśniać się: imperf: subj{cp(że)}
wyjaśniać się: imperf: subj{np(str); ncp(str,int); ncp(str,że)}
wyjaśnić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
wyjaśnić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśnić: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)} + {or}
wyjaśnić się: perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
wyjaśnić się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wyjaśnić się: perf: subj{cp(int)}
wyjaśnić się: perf: subj{cp(że)}
wyjaśnić się: perf: subj{np(str); ncp(str,int); ncp(str,że)}
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,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen)}
wyjść: perf: subj,controller{np(str); ncp(str,że)} + controllee{prepadjp(na,acc)} + {np(dat)}
wyjść: perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
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)} + {xp(abl)} + {xp(perl)}
wyjść: perf: subj{np(str)} + {prepnp(od,gen)}
wyjść: perf: subj{np(str)} + {prepnp(poza,acc)}
wyjść: perf: subj{np(str)} + {prepnp(za,acc)} + {fixed('za mąż')}
wyjść: perf: subj{np(str)} + {prepnp(z,inst)}
wykańczać: imperf: subj{np(str); ncp(str,że)} + {np(str)}
wykańczać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
wykańczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wykańczać się: imperf: subj{np(str)} + {prepnp(na,acc)}
wykazać: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
wykazać się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wykazywać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
wykazywać: imperf: subj{np(str)} + {or}
wykazywać się: imperf: subj{np(str)} + {np(inst)} + {or}
wykąpać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykąpać: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
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)} + controllee{xp(mod)}
wykonać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykonać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykonać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykonać się: perf: subj{np(str)}
wykonywać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
wykonywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykonywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wykonywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykonywać się: imperf: subj{np(str)}
wykończyć: perf: subj{np(str); ncp(str,że)} + {np(str)}
wykończyć: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {refl}
wykończyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wykończyć się: perf: subj{np(str)} + {prepnp(na,acc)}
wykopać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,loc)}
wykopać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
wykopać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykopać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wykopać: perf: subj{np(str)} + {xp(abl)} + {refl}
wykorzystać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wykorzystać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wykorzystać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {cp(żeby)}
wykorzystać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wykorzystać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
wykorzystać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykorzystywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wykorzystywać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wykorzystywać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {cp(żeby)}
wykorzystywać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wykorzystywać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(w,loc)}
wykorzystywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
wykraczać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst)} + {prepnp(poza,acc); prepncp(poza,acc,int); prepncp(poza,acc,że)}
wykraczać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,int); prepncp(przeciw,dat,że)}
wykreślić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wykreślić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wykreślić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wykryć: perf: subj{np(str)} + {cp(int)}
wykryć: perf: subj{np(str)} + obj{cp(że)}
wykryć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wykryć: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wykryć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wykryć się: perf: subj{cp(że)}
wykryć się: perf: subj{np(str)}
wykrywać: imperf: subj{np(str)} + {cp(int)}
wykrywać: imperf: subj{np(str)} + obj{cp(że)}
wykrywać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wykrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wykrywać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wykrywać się: imperf: subj{np(str)}
wykrzyczeć: perf: subj{np(str)} + {np(dat)} + {cp(int)}
wykrzyczeć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wykrzyczeć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wykrzyczeć: perf: subj{np(str)} + {np(dat)} + {or}
wykrzyczeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wykrzyczeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wykrzyczeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
wykrzyczeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wykrzyczeć: perf: subj{np(str)} + {prepnp(ku,dat)} + {cp(int)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(ku,dat)} + {cp(że)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(ku,dat)} + {cp(żeby)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(ku,dat)} + {or}
wykrzyczeć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wykrzyczeć: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
wykrzyczeć się: perf: subj{np(str)} + {prepnp(na,acc)}
wykrzykiwać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wykrzykiwać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wykrzykiwać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wykrzykiwać: imperf: subj{np(str)} + {np(dat)} + {or}
wykrzykiwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wykrzykiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wykrzykiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ku,dat)}
wykrzykiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(ku,dat)} + {cp(int)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(ku,dat)} + {cp(że)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(ku,dat)} + {cp(żeby)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(ku,dat)} + {or}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
wykrzykiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
wykrzyknąć: perf: subj{np(str)} + obj{np(str)}
wykrzyknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wykrzyknąć: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wykrzyknąć: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
wylądować: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
wylądować: perf: subj{np(str)} + {prepnp(z,inst)} + {advp(misc)}
wyleczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyleczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyleczyć się: perf: subj{np(str)} + {np(dat)}
wyleczyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyleczyć się: perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,gen)}
wyleczyć się: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wyleczyć się: perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wyleźć: perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyleźć: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyleźć: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
wyleźć: perf: subj{np(str)} + {prepnp(z,gen)}
wyliczać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyliczać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyliczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyliczać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
wyliczyć: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
wyliczyć: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
wyliczyć: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wyliczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyliczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyliczyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
wyłaniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyłaniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłaniać się: imperf: subj{np(str)} + {prepnp(z,gen)}
wyłaniać się: imperf: subj{np(str)} + {xp(abl)}
wyłazić: perf: subj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {fixed('na jaw')}
wyłazić: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wyłazić: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)} + {xp(perl)}
wyłazić: perf: subj{np(str)} + {prepnp(z,gen)}
wyłonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyłonić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyłonić się: perf: subj{np(str)} + {prepnp(z,gen)}
wyłonić się: perf: subj{np(str)} + {xp(abl)}
wymagać: imperf: subj{cp(int)} + {np(gen)}
wymagać: imperf: subj{cp(że)} + {np(gen)}
wymagać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(gen)}
wymagać: imperf: subj{np(str)} + obj{cp(że)} + {prepnp(od,gen)}
wymagać: imperf: subj{np(str)} + obj{np(gen); cp(żeby); ncp(gen,że); ncp(gen,żeby)} + {prepnp(od,gen)}
wymawiać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wymawiać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wymawiać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
wymawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wymawiać się: imperf: subj{np(str)} + {or}
wymawiać się: imperf: subj{np(str)} + {prepnp(od,gen)}
wymeldować: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wymeldować: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wymeldować: perf: subj{np(str)} + {prepnp(od,gen)} + {refl}
wymeldować: perf: subj{np(str)} + {xp(abl)} + {refl}
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)}
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)}
wymusić: imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst); ncp(inst,że)} + {prepnp(na,loc)}
wymusić: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
wymusić: imperf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {prepnp(na,loc)}
wymusić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wymusić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wymusić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
wymusić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wymuszać: imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(inst); ncp(inst,że)} + {prepnp(na,loc)}
wymuszać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {cp(że)}
wymuszać: imperf: subj{np(str)} + obj{cp(żeby)} + {np(inst)} + {prepnp(na,loc)}
wymuszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wymuszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wymuszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(za,acc)}
wymuszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wymyś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)}
wynegocjować: perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: perf: subj{np(str)} + obj{cp(int)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynegocjować: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: perf: subj{np(str)} + obj{cp(żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynegocjować: perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: perf: subj{np(str)} + obj{cp(że)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynegocjować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {prepnp(z,inst)}
wynegocjować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
wynieść: perf: {np(str)} + {xp(abl)} + {xp(adl)}
wynieść: perf: subj{np(str)} + {np(str)}
wynieść: perf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'niebiosa',natr)}
wynieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wynieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wynieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
wynieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
wynieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wynieść: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynieść się: perf: subj{np(str)} + {prepnp(nad,acc)}
wynieść się: perf: subj{np(str)} + {prepnp(ponad,acc)}
wynieść się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynikać: imperf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wyniknąć: perf: subj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że); prepncp(z,gen,żeby)}
wynosić: imperf: {np(str)} + {xp(abl)} + {xp(adl)}
wynosić: imperf: subj{np(str)} + {np(str)}
wynosić: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(pod,acc,pl,'niebiosa',natr)}
wynosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wynosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wynosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,acc)}
wynosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(ponad,acc)}
wynosić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wynosić: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynosić się: imperf: subj{np(str)} + {prepnp(nad,acc)}
wynosić się: imperf: subj{np(str)} + {prepnp(ponad,acc)}
wynosić się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wynurzyć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyobrazić: perf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrazić: perf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrazić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: imperf: subj{np(str)} + {cp(żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: imperf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że); ncp(str,żeby2)} + {lexnp(dat,_,'siebie',natr)}
wyobrażać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {lexnp(dat,_,'siebie',natr)}
wyodrębniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyodrębniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyodrębniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyodrębniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyodrębniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyodrębniać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(spośród,gen)}
wyodrębniać się: imperf: subj{np(str)} + {prepnp(od,gen)}
wyodrębniać się: imperf: subj{np(str)} + {prepnp(w,acc)}
wyodrębniać się: imperf: subj{np(str)} + {prepnp(z,gen)}
wyodrębnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyodrębnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyodrębnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(spośród,gen)}
wyodrębnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wyodrębnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyodrębnić się: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(spośród,gen)}
wyodrębnić się: perf: subj{np(str)} + {prepnp(od,gen)}
wyodrębnić się: perf: subj{np(str)} + {prepnp(w,acc)}
wyodrębnić się: perf: subj{np(str)} + {prepnp(z,gen)}
wypadać: imperf: {np(dat)} + {advp(pron)}
wypadać: imperf: subj,controllee{infp(_)} + controller{np(dat)}
wypadać: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {advp(misc)}
wypadać: imperf: subj{cp(żeby)} + {np(dat)} + {prepnp(z,gen)}
wypadać: imperf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
wypadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypadać: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypadać: imperf: subj{np(str)} + {prepnp(na,acc)}
wypadać: imperf: subj{np(str)} + {prepnp(w,loc)} + {advp(misc)}
wypadać: imperf: subj{np(str)} + {xp(temp)}
wypaść: perf: controller{np(dat)} + controllee{infp(_)}
wypaść: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {advp(misc)}
wypaść: perf: subj{cp(żeby)} + {np(dat)} + {prepnp(z,gen)}
wypaść: perf: subj{cp(że)} + {np(dat)} + {prepnp(z,gen)}
wypaść: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypaść: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypaść: perf: subj{np(str)} + {prepnp(na,acc)}
wypaść: perf: subj{np(str)} + {prepnp(w,loc)} + {advp(misc)}
wypaść: perf: subj{np(str)} + {xp(temp)}
wypatrywać: imperf: subj{np(str)} + {cp(int)} + {xp(abl)}
wypatrywać: imperf: subj{np(str)} + {cp(że)} + {xp(abl)}
wypatrywać: imperf: subj{np(str)} + obj{np(gen)} + {xp(abl)} + {xp(locat)}
wypatrywać: imperf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(str,pl,'oko',natr)}
wypatrzyć: perf: subj{np(str)} + {cp(int)} + {xp(abl)}
wypatrzyć: perf: subj{np(str)} + {cp(że)} + {xp(abl)}
wypatrzyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(locat)}
wypatrzyć: perf: subj{np(str)} + {prepnp(za,inst)} + {lexnp(str,pl,'oko',natr)}
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)} + {np(dat)} + {prepnp(z,gen)}
wypić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wypić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wypić: perf: subj{np(str)} + {prepnp(na,acc)}
wypierać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)} + {xp(abl)}
wypierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypierać się: imperf: subj{np(str)} + {cp(jakoby)}
wypierać się: imperf: subj{np(str)} + {cp(że)}
wypierać się: imperf: subj{np(str)} + {cp(żeby)}
wypierać się: imperf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
wypierać się: imperf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {or}
wypijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wypijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wypijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wypijać: imperf: subj{np(str)} + {prepnp(na,acc)}
wypłynąć: perf: subj{cp(że)} + {prepnp(z,gen)}
wypłynąć: perf: subj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
wypłynąć: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypłynąć: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypłynąć: perf: subj{np(str)} + {preplexnp(na,loc,sg,'fala',natr)}
wypłynąć: perf: subj{np(str)} + {prepnp(od,gen)}
wypływać: imperf: subj{cp(że)} + {prepnp(z,gen)}
wypływać: imperf: subj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,że)}
wypływać: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wypływać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypływać: imperf: subj{np(str)} + {preplexnp(na,loc,sg,'fala',natr)}
wypływać: imperf: subj{np(str)} + {prepnp(od,gen)}
wypływać się: perf: subj{np(str)}
wypogadzać: imperf: subj{np(str)} + {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)} + controllee{prepnp(jako,str)}
wypowiadać się: imperf: subj{np(str)} + {comprepnp(na temat)}
wypowiadać się: imperf: subj{np(str)} + {comprepnp(w kwestii)}
wypowiadać się: imperf: subj{np(str)} + {comprepnp(w sprawie)}
wypowiadać się: imperf: subj{np(str)} + {cp(int)}
wypowiadać się: imperf: subj{np(str)} + {or}
wypowiadać się: imperf: subj{np(str)} + {prepnp(co do,gen)}
wypowiadać się: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wypowiadać się: imperf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,że); prepncp(za,inst,żeby)}
wypowiadać się: imperf: subj{np(str)} + {prepnp(przez,acc)}
wypowiadać się: imperf: subj{np(str)} + {prepnp(w,loc)}
wypowiedzieć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wypowiedzieć: perf: subj{np(str)} + obj{np(str)} + {or}
wypowiedzieć się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wypowiedzieć się: perf: subj{np(str)} + {comprepnp(na temat)}
wypowiedzieć się: perf: subj{np(str)} + {comprepnp(w kwestii)}
wypowiedzieć się: perf: subj{np(str)} + {comprepnp(w sprawie)}
wypowiedzieć się: perf: subj{np(str)} + {cp(int)}
wypowiedzieć się: perf: subj{np(str)} + {or}
wypowiedzieć się: perf: subj{np(str)} + {prepnp(co do,gen)}
wypowiedzieć się: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
wypowiedzieć się: perf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst); prepncp(za,inst,że); prepncp(za,inst,żeby)}
wypowiedzieć się: perf: subj{np(str)} + {prepnp(przez,acc)}
wypowiedzieć się: perf: subj{np(str)} + {prepnp(w,loc)}
wypożyczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wypożyczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {prepnp(za,acc)}
wypożyczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(od,gen)} + {prepnp(za,acc)}
wypożyczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)} + {prepnp(za,acc)}
wypracować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wypracować się: perf: subj{np(str)}
wypraszać: imperf: subj,controller{np(str)} + controllee{infp(imperf)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: imperf: subj{np(str)} + {cp(jakoby)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: imperf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: imperf: subj{np(str)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: imperf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {xp(locat)}
wypraszać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
wypraszać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(żeby)}
wypraszać: imperf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(żeby)}
wypraszać: imperf: subj{np(str)} + {np(str)} + {lexnp(dat,_,'siebie',natr)}
wypraszać: imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {np(inst)} + {prepnp(u,gen)}
wypraszać: imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
wypraszać: imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(od,gen)}
wypraszać: imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {xp(locat)}
wypraszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wypraszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wypraszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wypraszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wypraszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprodukować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprodukować: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wyprodukować: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
wyprodukować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wypromować: perf: subj{np(str)} + {np(inst)} + {refl}
wypromować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wypromować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wypromować: perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wyprosić: perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {xp(locat)}
wyprosić: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)} + {xp(locat)}
wyprosić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {cp(żeby)}
wyprosić: perf: subj{np(str)} + {np(inst)} + {prepnp(u,gen)} + {cp(żeby)}
wyprosić: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)} + {np(inst)} + {prepnp(u,gen)}
wyprosić: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
wyprosić: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {prepnp(od,gen)}
wyprosić: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(inst)} + {xp(locat)}
wyprosić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
wyprosić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wyprosić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wyprosić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
wyprosić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyprostować: perf: subj{np(str)} + {cp(że)}
wyprostować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyprostować: perf: subj{np(str)} + obj{np(str)} + {or}
wyprostować się: perf: subj{np(str)} + {np(dat)}
wyprowadzać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pole',natr)}
wyprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyprowadzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprowadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wyprowadzać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
wyprowadzać się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wyprowadzać się: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wyprowadzać się: perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
wyprowadzać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyprowadzić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'pole',natr)}
wyprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyprowadzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyprowadzić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wyprowadzić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)} + {xp(perl)}
wyprowadzić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(od,gen)}
wyprowadzić się: perf: subj{np(str)} + {prepnp(do,gen)} + {xp(abl)}
wyprowadzić się: perf: subj{np(str)} + {prepnp(od,gen)} + {xp(adl)}
wyprowadzić się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyprzeć: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na rzecz)} + {xp(abl)}
wyprzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyprzeć się: perf: subj{np(str)} + {cp(jakoby)}
wyprzeć się: perf: subj{np(str)} + {cp(że)}
wyprzeć się: perf: subj{np(str)} + {cp(żeby)}
wyprzeć się: perf: subj{np(str)} + {np(gen)} + {comprepnp(na rzecz)}
wyprzeć się: perf: subj{np(str)} + {np(gen); ncp(gen,int); ncp(gen,że)} + {or}
wyprzedzać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyprzedzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
wyprzedzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
wyprzedzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {preplexnp(pod,inst,_,'wzgląd',atr)}
wyprzedzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {prepnp(w,loc)}
wypuszczać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypuszczać się: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wypuścić: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wypuścić się: perf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyrabiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyrabiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyrabiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyrabiać się: imperf: subj{np(str)} + {np(dat)}
wyrabiać się: imperf: subj{np(str)} + {prepnp(u,gen)}
wyrabiać się: imperf: subj{np(str)} + {prepnp(z,inst)}
wyrastać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrastać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyrastać: imperf: subj{np(str)} + {prepnp(na,acc)}
wyrazić: perf: subj{np(str)} + {cp(że)}
wyrazić: perf: subj{np(str)} + obj{ncp(str,że)}
wyrazić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyrazić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,że)}
wyrazić: perf: subj{np(str)} + {or}
wyrazić się: perf: subj{np(str)} + controller{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + controllee{xp(mod)}
wyrazić się: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(u,gen)}
wyrazić się: perf: subj{np(str)} + {or}
wyrazić się: perf: subj{np(str)} + {prepnp(przez,acc)}
wyrazić się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
wyrażać: imperf: subj{np(str)} + {cp(że)}
wyrażać: imperf: subj{np(str)} + obj{ncp(str,int)}
wyrażać: imperf: subj{np(str)} + obj{ncp(str,że)}
wyrażać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyrażać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wyrażać: imperf: subj{np(str)} + obj{np(str)} + {prepncp(w,loc,że)}
wyrażać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrażać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wyrażać się: imperf: subj{np(str)} + controller{prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + controllee{xp(mod)}
wyrażać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(u,gen)}
wyrażać się: imperf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int); prepncp(przez,acc,że)}
wyrażać się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(przez,acc,int)}
wyrażać się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
wyrobić: perf: subj{np(str)} + {advp(misc)}
wyrobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrobić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
wyrobić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyrobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wyrobić się: perf: subj{np(str)} + {advp(misc)}
wyrobić się: perf: subj{np(str)} + {np(dat)}
wyrobić się: perf: subj{np(str)} + {prepnp(u,gen)}
wyrobić się: perf: subj{np(str)} + {prepnp(w,loc)}
wyrobić się: perf: subj{np(str)} + {prepnp(z,inst)}
wyrosnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrosnąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyrosnąć: perf: subj{np(str)} + {prepnp(na,acc)}
wyrównać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
wyrównać się: perf: subj{np(str)} + {prepnp(do,gen)}
wyruszać: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wyruszać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
wyruszać: imperf: subj{np(str)} + {np(inst)} + {xp(abl)} + {xp(adl)}
wyruszyć: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
wyruszyć: perf: subj{np(str)} + {np(inst)} + {xp(abl)}
wyruszyć: perf: subj{np(str)} + {np(inst)} + {xp(adl)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyrwać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {preplexnp(z,inst,pl,'korzeń',natr)}
wyrwać: perf: subj{np(str)} + {xp(adl)}
wyrwać się: perf: subj{cp(że)} + {np(dat)}
wyrwać się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrwać się: perf: subj{np(str)} + {prepnp(do,gen)}
wyrwać się: perf: subj{np(str)} + {prepnp(z,inst)}
wyrwać się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyrwać się: perf: subj{or} + {np(dat)} + {prepnp(z,gen)}
wyrywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wyrywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
wyrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyrywać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {preplexnp(z,inst,pl,'korzeń',natr)}
wyrywać: imperf: subj{np(str)} + {xp(adl)}
wyrywać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wyrywać się: imperf: subj{np(str)} + {prepnp(do,gen)}
wyrywać się: imperf: subj{np(str)} + {prepnp(z,inst)}
wyrywać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyrywać się: imperf: subj{or} + {np(dat)} + {prepnp(z,gen)}
wyrządzić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wyrzucać: imperf: {np(dat)} + {np(str)}
wyrzucać: imperf: {np(dat)} + {or}
wyrzucać: imperf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyrzucać: imperf: subj{np(str)} + {np(dat)} + {np(str)}
wyrzucać: imperf: subj{np(str)} + {np(dat)} + {np(str); ncp(str,że)}
wyrzucać: imperf: subj{np(str)} + {np(dat)} + {or}
wyrzucać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'błoto',natr)}
wyrzucać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wyrzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wyrzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)}
wyrzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {xp(abl)}
wyrzucać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyrzucać: imperf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wyrzucić: perf: {np(dat)} + {np(str)}
wyrzucić: perf: {np(dat)} + {or}
wyrzucić: perf: subj{np(str)} + {cp(int)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucić: perf: subj{np(str)} + {cp(że)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyrzucić: perf: subj{np(str)} + {np(dat)} + {ncp(str,że)}
wyrzucić: perf: subj{np(str)} + {np(dat)} + {np(str)}
wyrzucić: perf: subj{np(str)} + {np(dat)} + {or}
wyrzucić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,acc,sg,'błoto',natr)}
wyrzucić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)}
wyrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wyrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(z,gen)}
wyrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przez,acc)} + {xp(abl)}
wyrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {xp(abl)}
wyrzucić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wyrzucić: perf: subj{np(str)} + {preplexnp(z,gen,_,'siebie',natr)} + {or}
wysiadać: imperf: subj{np(str)} + {np(dat)}
wysiadać: imperf: subj{np(str)} + {prepnp(przy,loc)}
wysiadać: imperf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wysiąść: perf: subj{np(str)} + {np(dat)}
wysiąść: perf: subj{np(str)} + {prepnp(przy,loc)}
wysiąść: perf: subj{np(str)} + {prepnp(z,gen)} + {xp(locat)}
wyskakiwać: imperf: subj{cp(że)} + {np(dat)}
wyskakiwać: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyskakiwać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(z,gen)}
wyskakiwać: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wyskakiwać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wyskakiwać: imperf: subj{np(str)} + {xp(abl)} + {xp(perl)}
wyskakiwać: imperf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wyskakiwać: imperf: subj{or} + {np(dat)}
wyskoczyć: perf: subj{cp(że)} + {np(dat)}
wyskoczyć: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wyskoczyć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyskoczyć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
wyskoczyć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wyskoczyć: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(że)}
wyskoczyć: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(z,inst)} + {cp(żeby)}
wyskoczyć: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
wyskoczyć: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
wyskoczyć: perf: subj{np(str)} + {prepnp(po,acc)} + {xp(adl)}
wyskoczyć: perf: subj{np(str)} + {prepnp(z,gen)}
wyskoczyć: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
wyskoczyć: perf: subj{np(str)} + {xp(abl)} + {xp(perl)}
wyskoczyć: perf: subj{np(str)} + {xp(adl)} + {xp(perl)}
wyskoczyć: perf: subj{or} + {np(dat)}
wysłuchać: perf: subj{np(str)} + obj{cp(int)}
wysłuchać: perf: subj{np(str)} + obj{cp(jak)}
wysłuchać: perf: subj{np(str)} + obj{cp(że)}
wysłuchać: perf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)}
wysłuchać: perf: subj{np(str)} + obj{np(str)}
wysłuchiwać: imperf: subj{np(str)} + obj{cp(int)}
wysłuchiwać: imperf: subj{np(str)} + obj{cp(jak)}
wysłuchiwać: imperf: subj{np(str)} + obj{cp(że)}
wysłuchiwać: imperf: subj{np(str)} + obj{np(gen); ncp(gen,int); ncp(gen,jak); ncp(gen,że)}
wysłuchiwać: imperf: subj{np(str)} + obj{np(str)}
wyspać się: perf: subj{np(str)}
wystarczać: imperf: {np(dat)} + {np(gen)} + {prepnp(na,acc)}
wystarczać: imperf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
wystarczać: imperf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: imperf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: imperf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczać: imperf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
wystarczać: imperf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
wystarczać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystarczyć: perf: {np(dat)} + {np(gen)} + {prepnp(na,acc)}
wystarczyć: perf: {np(dat)} + {np(gen)} + {prepnp(za,acc)}
wystarczyć: perf: subj,controllee{np(str); cp(gdy); cp(żeby); ncp(str,że); infp(_)} + controller{np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: perf: subj{cp(jeśli)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: perf: subj{cp(że)} + {np(dat)} + {prepnp(do,gen); cp(żeby); prepncp(do,gen,żeby)}
wystarczyć: perf: subj{cp(że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: perf: subj{np(str); ncp(str,że)} + {np(dat)} + {prepnp(za,acc)}
wystarczyć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystawać: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wystawać: imperf: subj{np(str)} + {xp(adl)}
wystawać: imperf: subj{np(str)} + {xp(locat)}
wystawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wystawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wystawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wystawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wystawiać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wystawiać: imperf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wystawiać się: imperf: subj{np(str)} + {xp(locat)}
wystawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wystawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wystawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wystawić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wystawić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
wystawić: perf: subj{np(str)} + {prepnp(na,acc)} + {refl}
wystawić się: perf: subj{np(str)} + {xp(locat)}
wystąpić: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
wystąpić: perf: subj{ncp(str,że)} + {prepnp(u,gen)}
wystąpić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wystąpić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
wystąpić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
wystąpić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
wystąpić: perf: subj{np(str)} + {prepnp(na,loc)}
wystąpić: perf: subj{np(str)} + {prepnp(przed,inst)}
wystąpić: perf: subj{np(str)} + {prepnp(u,gen)}
wystąpić: perf: subj{np(str)} + {prepnp(w,loc)}
wystąpić: perf: subj{np(str)} + {prepnp(z,gen)}
występować: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
występować: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
występować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
występować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(przeciw,dat)}
występować: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
występować: imperf: subj{np(str)} + {prepnp(na,loc)}
występować: imperf: subj{np(str)} + {prepnp(przed,inst)}
występować: imperf: subj{np(str)} + {prepnp(u,gen)}
występować: imperf: subj{np(str)} + {prepnp(w,loc)}
występować: imperf: subj{np(str)} + {prepnp(z,gen)}
występować: imperf: subj{np(str)} + {xp(locat)}
wystrzelić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,gen)}
wystrzelić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wystrzelić: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wystrzelić: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
wystrzelić: perf: subj{np(str)} + {prepnp(z,inst)}
wysunąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysunąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wysunąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysunąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wysunąć się: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
wysuwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wysuwać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wysuwać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wysuwać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wysuwać się: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
wysypać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysypać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypać się: perf: subj{np(str)} + {cp(że)}
wysypać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypać się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wysypywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wysypywać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypywać się: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wysypywać się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {cp(int)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {cp(żeby)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {cp(że)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',natr)} + {or}
wyszeptać: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)} + {or}
wyszeptać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(do,gen,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'ucho',ratr)}
wyszeptać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyszeptać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wyszeptać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wyszeptać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
wyszeptać: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
wyszukiwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
wyszukiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
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)}
wytaczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wytaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wytaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wytaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytaczać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wytaczać się: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytknąć: perf: subj{np(str)} + obj{np(str)} + {cp(że)} + {lexnp(inst,_,'palec',natr)}
wytknąć: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
wytknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {lexnp(inst,_,'palec',natr)}
wytknąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wytłumaczyć: perf: subj{np(str)} + {np(dat)} + {or}
wytłumaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wytłumaczyć: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst); ncp(inst,że)}
wytłumaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wytłumaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytłumaczyć się: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wytłumaczyć się: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
wytłumaczyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wytłumaczyć się: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)}
wytłumaczyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
wytłumaczyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {or}
wytłumaczyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wytoczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wytoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wytoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
wytoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytoczyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wytoczyć się: perf: subj{np(str)} + {xp(abl)} + {xp(adl)}
wytrzymać: perf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
wytrzymać: perf: subj{np(str)} + {np(str)} + {xp(dur)}
wytrzymać: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)}
wytrzymywać: imperf: subj{np(str)} + {np(str); ncp(str,int); ncp(str,że)}
wytrzymywać: imperf: subj{np(str)} + {np(str)} + {xp(dur)}
wytrzymywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(dur)}
wytwarzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytwarzać się: imperf: subj{np(str)} + {prepnp(z,gen)}
wytworzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
wytworzyć się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
wytworzyć się: perf: subj{np(str)} + {prepnp(z,gen)}
wytykać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)} + {lexnp(inst,_,'palec',natr)}
wytykać: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
wytykać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)} + {lexnp(inst,_,'palec',natr)}
wytykać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
wywalczyć: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wywalczyć: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
wywalczyć: perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst); ncp(inst,że)}
wywalczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
wywalczyć: perf: subj{np(str)} + {prepnp(dla,gen)} + {cp(żeby)}
wywiązać się: perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywiązywać się: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wywierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
wywieźć: perf: subj{np(str)} + obj{np(str)} + {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)}
wywnioskować: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wywnioskować: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnioskować: perf: subj{np(str)} + {or}
wywnioskować: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)}
wywnioskować: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
wywnioskować: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {advp(pron)}
wywnioskować: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(int)}
wywnioskować: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(że)}
wywnioskować: perf: subj{np(str)} + {prepnp(po,loc); prepncp(po,loc,int); prepncp(po,loc,że)} + {cp(żeby2)}
wywnioskować: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {advp(pron)}
wywnioskować: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(int)}
wywnioskować: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(że)}
wywnioskować: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)} + {cp(żeby2)}
wywołać: perf: subj{ncp(str,int)} + obj{np(str)}
wywołać: perf: subj{ncp(str,że)} + {np(str)} + {prepnp(wśród,gen)}
wywołać: perf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
wywołać: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wywołać: perf: subj{np(str)} + {np(str)} + {prepnp(wśród,gen)}
wywołać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywołać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wywołać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wywołać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wywołać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywoływać: imperf: subj{np(str); ncp(str,że)} + {np(str)} + {prepnp(w,loc)}
wywoływać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wywoływać: imperf: subj{np(str)} + {np(str)} + {prepnp(wśród,gen)}
wywoływać: imperf: subj{np(str)} + obj{ncp(str,że)}
wywoływać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wywoływać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wywoływać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wywoływać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
wywoływać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wywozić: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,pl,'taczka',natr)}
wywozić: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
wywracać: imperf: subj{np(str)} + {lexnp(inst,pl,'oko',atr)}
wywracać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {lexnp(inst,pl,'noga',natr)} + {preplexnp(do,gen,sg,'góra',natr)}
wywracać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wywracać się: imperf: subj{np(str)} + {np(dat)}
wywrócić: perf: subj{np(str)} + {lexnp(inst,pl,'oko',atr)}
wywrócić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
wywrócić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(do,gen,sg,'góra',natr)}
wywrócić się: perf: subj{np(str)} + {np(dat)}
wyzbyć się: perf: subj{np(str)} + {np(gen)}
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)} + controllee{prepnp(jako,str)}
wyznaczać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
wyznaczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyznaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyznaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wyznaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
wyznaczyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(na,acc)}
wyznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
wyznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyznaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
wyznać: perf: subj{np(str)} + {np(dat)} + {cp(int)}
wyznać: perf: subj{np(str)} + {np(dat)} + {cp(że)}
wyznać: perf: subj{np(str)} + {np(dat)} + {or}
wyznać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wyznać się: perf: subj{np(str)} + {or}
wyznać się: perf: subj{np(str)} + {prepnp(na,loc)}
wyznać się: perf: subj{np(str)} + {prepnp(w,loc)}
wyznawać: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
wyznawać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
wyznawać: imperf: subj{np(str)} + {np(dat)} + {or}
wyznawać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
wyznawać się: imperf: subj{np(str)} + {or}
wyznawać się: imperf: subj{np(str)} + {prepnp(na,loc)}
wyznawać się: imperf: subj{np(str)} + {prepnp(w,loc)}
wyzwać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyzwać: perf: subj{np(str)} + obj{np(str)} + {or}
wyzwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyzwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzwać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wyzwalać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
wyzwalać: imperf: subj{np(str)} + {np(inst)} + {prepnp(spod,gen)} + {refl}
wyzwalać: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wyzwalać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyzwalać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spod,gen)}
wyzwalać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyzwalać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyzwalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzwalać się: imperf: subj{np(str)} + {prepnp(na,acc)}
wyzwalać się: imperf: subj{np(str)} + {prepnp(w,loc)}
wyzwolić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
wyzwolić: perf: subj{np(str)} + {np(inst)} + {prepnp(spod,gen)} + {refl}
wyzwolić: perf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)} + {refl}
wyzwolić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
wyzwolić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(spod,gen)}
wyzwolić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
wyzwolić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,gen)}
wyzwolić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzwolić się: perf: subj{np(str)} + {prepnp(na,acc)}
wyzwolić się: perf: subj{np(str)} + {prepnp(w,loc)}
wyzywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
wyzywać: imperf: subj{np(str)} + obj{np(str)} + {or}
wyzywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wyzywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wyzywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wzbudzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
wzbudzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
wzdychać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
wzdychać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
wzdychać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
wzdychać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,int); prepncp(do,gen,żeby)}
wzdychać: imperf: subj{np(str)} + {prepnp(na,acc)}
wzdychać: imperf: subj{np(str)} + {prepnp(za,inst); prepncp(za,inst,int); prepncp(za,inst,żeby)}
wzdychać: imperf: subj{np(str)} + {prepnp(z,gen)}
wziąć: perf: {np(str)} + {prepnp(na,acc)}
wziąć: perf: subj{np(str)} + {cp(że)} + {preplexnp(do,gen,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + {lexnp(part,sg,'woda',natr)} + {preplexnp(w,acc,pl,'usta',natr)}
wziąć: perf: subj{np(str)} + {ncp(str,że)} + {preplexnp(do,gen,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + {ncp(str,że)} + {preplexnp(na,acc,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + {np(str)}
wziąć: perf: subj{np(str)} + {np(str); ncp(str,że); ncp(str,żeby)} + {prepnp(do,gen)} + {lexnp(dat,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + {np(str)} + {preplexnp(do,gen,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + {np(str)} + {preplexnp(na,acc,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(za,acc)}
wziąć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(za,acc)}
wziąć: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {xp(abl)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
wziąć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że); ncp(str,żeby)} + {preplexnp(pod,acc,sg,'uwaga',atr)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że); prepncp(za,acc,żeby)}
wziąć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wziąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)} + {lexnp(dat,_,'siebie',natr)}
wziąć: perf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(str,sg,'góra',natr)}
wziąć: perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'łapa',natr)}
wziąć: perf: subj{np(str)} + {prepnp(od,gen)} + {preplexnp(w,acc,sg,'skóra',natr)}
wziąć: perf: subj{np(str)} + {prepnp(za,acc)} + {refl}
wziąć: perf: subj{np(str)} + {prepnp(z,inst)} + {lexnp(str,sg,'ślub',atr)}
wziąć się: perf: subj{np(str)} + {preplexnp(w,acc,pl,'karb',natr)}
wziąć się: perf: subj{np(str)} + {preplexnp(w,acc,pl,'ryza',natr)}
wziąć się: perf: subj{np(str)} + {preplexnp(w,acc,sg,'garść',natr)}
wziąć się: perf: subj{np(str)} + {prepnp(do,gen)}
wziąć się: perf: subj{np(str)} + {prepnp(na,acc)}
wziąć się: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
wziąć się: perf: subj{np(str)} + {prepnp(za,acc)}
wziąć się: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
wziąć się: perf: subj{np(str)} + {xp(abl)}
wzmacniać: imperf: subj{np(str)} + {np(inst)} + {refl}
wzmacniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wzmacniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wzmacniać: imperf: subj{np(str)} + {prepnp(o,acc)} + {refl}
wzmagać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wzmagać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
wzmagać się: imperf: subj{np(str)} + {prepnp(u,gen)}
wzmagać się: imperf: subj{np(str)} + {prepnp(w,loc)}
wzmocnić: perf: subj{np(str)} + {np(inst)} + {refl}
wzmocnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
wzmocnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
wzmocnić: perf: subj{np(str)} + {prepnp(o,acc)} + {refl}
wzmóc: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(u,gen)}
wzmóc: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {prepnp(w,loc)}
wzmóc się: perf: subj{np(str)} + {prepnp(u,gen)}
wzmóc się: perf: subj{np(str)} + {prepnp(w,loc)}
wznosić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
wznosić się: imperf: subj{np(str)} + {np(inst)} + {xp(adl)}
wznosić się: imperf: subj{np(str)} + {prepnp(na,acc)}
wznosić się: imperf: subj{np(str)} + {prepnp(ponad,acc)}
wznosić się: imperf: subj{np(str)} + {xp(locat)}
wznowić: perf: subj{np(str)} + obj{np(str)}
wzorować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
wzorować się: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
wzrastać: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wzrastać: imperf: subj{np(str)} + {prepnp(w,acc)}
wzrastać: imperf: subj{np(str)} + {prepnp(w,loc)}
wzrosnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
wzrosnąć: perf: subj{np(str)} + {prepnp(w,acc)}
wzrosnąć: perf: subj{np(str)} + {prepnp(w,loc)}
wzruszać: imperf: subj{cp(że); ncp(str,że)} + obj{np(str)}
wzruszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wzruszać: imperf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(inst,pl,'ramię',natr)}
wzruszać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)}
wzruszać się: imperf: subj{np(str)} + {or}
wzruszać się: imperf: subj{np(str)} + {prepnp(nad,inst)}
wzruszyć: perf: subj{cp(że); ncp(str,że)} + {np(str)}
wzruszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
wzruszyć: perf: subj{np(str)} + {prepnp(nad,inst)} + {lexnp(inst,pl,'ramię',atr)}
wzruszyć się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
wzruszyć się: perf: subj{np(str)} + {or}
wzruszyć się: perf: subj{np(str)} + {prepnp(nad,inst)}
wzywać: imperf: subj{np(str)} + {np(gen)}
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)}
zabawić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zabawić: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
zabawić się: perf: subj{np(str)} + {np(inst)}
zabawić się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zabezpieczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabezpieczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabezpieczać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabezpieczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zabezpieczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabezpieczyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)}
zabezpieczyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(przed,inst)}
zabłądzić: perf: subj{np(str)} + {xp(adl)}
zabłądzić: perf: subj{np(str)} + {xp(locat)}
zabrać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zabrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zabrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zabrać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zabrać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zabrać się: perf: subj{np(str)} + {prepnp(do,gen)}
zabrać się: perf: subj{np(str)} + {prepnp(za,acc)}
zabrać się: perf: subj{np(str)} + {xp(adl)}
zabraknąć: perf: {np(dat)} + {np(gen)} + {cp(żeby)}
zabraknąć: perf: {np(dat)} + {np(gen)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zabraknąć: perf: {np(dat)} + {prepnp(dla,gen)} + {lexnp(gen,pl,'słowo',atr)}
zabraknąć: perf: {np(dat)} + {prepnp(na,acc)} + {lexnp(gen,pl,'słowo',atr)}
zabraknąć: perf: {np(gen)} + {xp(locat)}
zabraniać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zabraniać: imperf: subj{np(str)} + {np(dat)} + {ncp(gen,żeby)}
zabraniać: imperf: subj{np(str)} + obj,controllee{np(gen); infp(_)} + controller{np(dat)}
zabronić: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zabronić: perf: subj{np(str)} + {np(dat)} + {ncp(gen,żeby)}
zabronić: perf: subj{np(str)} + obj,controllee{np(gen); infp(_)} + controller{np(dat)}
zabrzmieć: perf: subj,controller{np(str)} + controllee{or}
zabrzmieć: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'usta',ratr)}
zabrzmieć: perf: subj,controller{np(str)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',ratr)}
zabrzmieć: perf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(dla,gen)}
zabrzmieć: perf: subj,controller{np(str); ncp(str,że)} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',ratr)}
zabrzmieć: perf: subj,controller{or} + controllee{xp(mod)} + {np(dat)} + {preplexnp(w,loc,pl,'ucho',ratr)}
zabrzmieć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {preplexnp(w,loc,pl,'ucho',ratr)}
zabrzmieć: perf: subj{np(str)} + {prepnp(w,loc)}
zachcieć: perf: controller{np(str)} + controllee{infp(_)}
zachcieć: perf: subj{np(str)} + {cp(żeby)}
zachcieć: perf: subj{np(str)} + {np(gen)}
zachcieć: perf: subj{np(str)} + {xp(adl)}
zachcieć się: imperf: controller{np(dat)} + controllee{infp(_)}
zachcieć się: imperf: {np(dat)} + {cp(żeby)}
zachcieć się: imperf: {np(dat)} + {np(gen)}
zachcieć się: imperf: {np(dat)} + {xp(adl)}
zachęcać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zachęcać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zachęcać się: imperf: subj{np(str)} + {prepnp(do,gen)}
zachęcić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zachęcić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zachęcić się: perf: subj{np(str)} + {prepnp(do,gen)}
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)}
zachwalać: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)} + {refl}
zachwalać: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)} + {refl}
zachwalać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zachwalać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zachwalać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zachwalać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {cp(że)}
zachwalać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zachwalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)} + {prepnp(za,acc); prepncp(za,acc,że)}
zachwiać: perf: subj{np(str)} + obj{np(inst)}
zachwiać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zachwiać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zachwiać się: perf: subj{np(str)} + {prepnp(w,loc)}
zachwycać: imperf: subj{cp(int)} + {np(str)}
zachwycać: imperf: subj{cp(jak)} + {np(str)}
zachwycać: imperf: subj{cp(kiedy)} + {np(str)}
zachwycać: imperf: subj{cp(że)} + {np(str)}
zachwycać: imperf: subj{ncp(str,int)} + {np(str)}
zachwycać: imperf: subj{ncp(str,że)} + {np(str)}
zachwycać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycać się: imperf: subj{np(str)} + {cp(gdy)}
zachwycać się: imperf: subj{np(str)} + {cp(jak)}
zachwycać się: imperf: subj{np(str)} + {cp(jeśli)}
zachwycać się: imperf: subj{np(str)} + {cp(że)}
zachwycać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zachwycać się: imperf: subj{np(str)} + {or}
zachwycać się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zaciąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zaciąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zaciąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zaciąć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zaciąć się: perf: subj{np(str)} + {cp(że)}
zaciąć się: perf: subj{np(str)} + {cp(żeby)}
zaciąć się: perf: subj{np(str)} + {np(dat)}
zaciąć się: perf: subj{np(str)} + {prepnp(na,loc)}
zaciąć się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zaciążyć: perf: subj{np(str); ncp(str,że)} + {prepnp(nad,inst); prepncp(nad,inst,że)}
zaciążyć: perf: subj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zaciążyć: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zaciążyć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zaciążyć: perf: subj{np(str)} + {prepnp(z,inst)}
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}
zacierać: imperf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(inst)}
zacierać: imperf: subj{np(str)} + {prepnp(do,gen)} + {lexnp(str,pl,'ręka',natr)}
zacierać: imperf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,pl,'ręka',natr)}
zacierać się: imperf: subj{np(str); ncp(str,że)} + {np(dat)}
zacinać: imperf: {np(inst)} + {xp(abl)} + {xp(adl)}
zacinać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(w,acc)}
zacinać: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zacinać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zacinać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zacinać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zacinać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zacinać się: imperf: subj{np(str)} + {np(dat)}
zacinać się: imperf: subj{np(str)} + {prepnp(na,loc)}
zacinać się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zacząć: perf: subj,controller{E} + controllee{infp(imperf)}
zacząć: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zacząć się: perf: {prepnp(od,gen); prepncp(od,gen,że)}
zacząć się: perf: subj{np(str)} + {np(inst)}
zacząć się: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zacząć się: perf: subj{np(str)} + {xp(locat)}
zacząć się: perf: subj{np(str)} + {xp(temp)}
zaczekać: perf: subj{np(str)} + {prepnp(na,acc); cp(aż); cp(int); cp(jak); cp(kiedy); cp(że); cp(żeby); prepncp(na,acc,aż); prepncp(na,acc,int); prepncp(na,acc,jak); prepncp(na,acc,kiedy); prepncp(na,acc,że); prepncp(na,acc,żeby)} + {prepnp(z,inst)} + {xp(dur)}
zaczekać: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(aż)} + {xp(dur)}
zaczekać: perf: subj{np(str)} + {xp(dur)} + {xp(locat)}
zaczepiać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zaczepiać: imperf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zaczepiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zaczepiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zaczepiać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zaczepiać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)}
zaczepiać się: imperf: subj{np(str)} + {xp(locat)}
zaczepić: perf: subj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zaczepić: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zaczepić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zaczepić: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zaczepić się: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zaczepić się: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(za,acc)}
zaczepić się: perf: subj{np(str)} + {xp(locat)}
zaczynać: imperf: subj,controller{E} + controllee{infp(imperf)}
zaczynać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zaczynać: imperf: subj{np(str)} + {prepnp(z,inst)}
zaczynać się: imperf: subj{np(str)} + {np(dat)}
zaczynać się: imperf: subj{np(str)} + {np(inst)}
zaczynać się: imperf: subj{np(str)} + {prepnp(na,acc)}
zaczynać się: imperf: subj{np(str)} + {prepnp(od,gen)}
zadać: perf: subj{np(str)} + {np(dat)} + {np(gen)}
zadać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadać się: perf: subj{np(str)} + {prepnp(z,inst)}
zadawać: imperf: subj{np(str)} + {np(dat)} + {np(gen)}
zadawać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zadawać się: imperf: subj{np(str)} + {prepnp(z,inst)}
zadbać: perf: subj{np(str)} + {prepnp(o,acc); cp(żeby); prepncp(o,acc,żeby)}
zadebiutować: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(inst)} + {xp(locat)}
zadecydować: perf: subj{np(str)} + {advp(pron)}
zadecydować: perf: subj{np(str)} + {comprepnp(w sprawie)}
zadecydować: perf: subj{np(str)} + {cp(int)}
zadecydować: perf: subj{np(str)} + {cp(że)}
zadecydować: perf: subj{np(str)} + {cp(żeby)}
zadecydować: perf: subj{np(str); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zadecydować: perf: subj{np(str)} + {or}
zadecydować: perf: subj{np(str)} + {prepncp(o,loc,żeby)}
zadecydować się: perf: subj{cp(int)}
zadecydować się: perf: subj{np(str)}
zadedykować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zadeklarować: perf: subj{np(str)} + {np(dat)} + {cp(int)}
zadeklarować: perf: subj{np(str)} + {np(dat)} + {or}
zadeklarować: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zadeklarować się: perf: subj,controller{np(str)} + controllee{infp(_)}
zadeklarować się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zadeklarować się: perf: subj{np(str)} + {cp(int)}
zadeklarować się: perf: subj{np(str)} + {cp(że)}
zadeklarować się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zadeklarować się: perf: subj{np(str)} + {or}
zadeklarować się: perf: subj{np(str)} + {preplexnp(po,loc,sg,'strona',ratr)}
zadeklarować się: perf: subj{np(str)} + {prepnp(przeciw,dat); prepnp(za,inst)}
zademonstrować: perf: subj{np(str)} + {comprepnp(na rzecz)}
zademonstrować: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
zademonstrować: perf: subj{np(str)} + obj{cp(int)} + {prepnp(przed,inst)}
zademonstrować: perf: subj{np(str)} + obj{cp(int)} + {prepnp(wobec,gen)}
zademonstrować: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zademonstrować: perf: subj{np(str)} + obj{cp(że)} + {prepnp(przed,inst)}
zademonstrować: perf: subj{np(str)} + obj{cp(że)} + {prepnp(wobec,gen)}
zademonstrować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zademonstrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(przed,inst)}
zademonstrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
zademonstrować: perf: subj{np(str)} + {prepnp(przeciw,dat)}
zademonstrować: perf: subj{np(str)} + {prepnp(za,inst)}
zadłużyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)}
zadłużyć: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(u,gen); prepnp(w,loc)} + {refl}
zadomowić się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zadomowić się: perf: subj{np(str)} + {prepnp(u,gen)}
zadomowić się: perf: subj{np(str)} + {prepnp(w,loc)}
zadowalać: imperf: subj{cp(że)} + {np(str)}
zadowalać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)}
zadowalać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zadowolić: perf: subj{cp(że)} + {np(str)}
zadowolić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst)}
zadowolić się: perf: subj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zadrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zadrzeć: perf: subj{np(str)} + {prepnp(z,inst)}
zadrzeć się: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zadzierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zadzierać: imperf: subj{np(str)} + {prepnp(z,inst)}
zadzierać się: imperf: subj{np(str)} + {np(dat)} + {xp(adl)}
zadzwonić: perf: {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zadzwonić: perf: {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
zadzwonić: perf: subj{np(str)} + {np(dat)}
zadzwonić: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zadzwonić: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'ucho',natr)}
zadzwonić: perf: subj{np(str)} + {np(inst)}
zadzwonić: perf: subj{np(str)} + {preplexnp(do,gen,pl,'drzwi',atr)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
zadzwonić: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
zadzwonić: perf: subj{np(str)} + {prepnp(na,acc)}
zafundować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zafundować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zagadać: perf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
zagadać: perf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
zagadać: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zagadać: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zagadać: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zagadać: perf: subj{np(str)} + obj{np(str)} + {or}
zagadać: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadać: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadać: perf: subj{np(str)} + {prepadjp(po,postp)}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadać: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadać: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
zagadać: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadać: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagadać: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
zagadać: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zagadać: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zagadać: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
zagadać się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(z,inst)}
zagadać się: perf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadać się: perf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(na temat)}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {comprepnp(w sprawie)}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {or}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadywać: imperf: subj{np(str)} + {prepadjp(po,postp)}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(na temat)}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
zagadywać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zagadywać: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)} + {prepnp(z,inst)}
zagadywać: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagadywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(w sprawie)}
zagadywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zagadywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zagadywać: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(żeby)}
zagadywać się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {prepnp(z,inst)}
zagadywać się: imperf: subj{np(str)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)} + {prepnp(z,inst)}
zagadywać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {comprepnp(na temat)}
zagarnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zagarniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zaginąć: perf: subj{np(str)} + {xp(locat)} + {xp(temp)}
zaglądać: imperf: subj{np(str)} + {cp(int)}
zaglądać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
zaglądać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zaglądać: imperf: subj{np(str)} + {prepnp(na,acc)}
zaglądać: imperf: subj{np(str)} + {xp(adl)}
zagłuszać: imperf: subj{np(str)} + {np(inst)} + {refl}
zagłuszać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
zagłuszyć: perf: subj{np(str)} + {np(inst)} + {refl}
zagłuszyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,loc)}
zagospodarować: perf: subj{np(str)} + obj{np(str)}
zagospodarować się: perf: subj{np(str)} + {xp(locat)}
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}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {cp(int)}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {or}
zahaczać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zahaczać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zahaczać się: imperf: subj{np(str)} + {xp(locat)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(o,acc)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {or}
zahaczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zahaczyć się: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(o,acc)}
zahaczyć się: perf: subj{np(str)} + {xp(locat)}
zainicjować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zainteresować: perf: subj{cp(int)} + {np(str)}
zainteresować: perf: subj{cp(że)} + {np(str)}
zainteresować: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zainteresować: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zainteresować się: perf: subj{np(str)} + {cp(int)}
zainteresować się: perf: subj{np(str)} + {np(inst); cp(że); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)}
zainwestować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc); prepncp(w,acc,żeby)}
zajadać: imperf: subj{np(str)} + obj{np(str)}
zajadać się: imperf: subj{np(str)} + {np(inst)}
zająć: perf: subj{np(str)} + obj{lexnp(str,_,'miejsce',atr)} + {prepnp(w,loc)}
zająć: perf: subj{np(str)} + obj{lexnp(str,_,'pozycja',atr)} + {prepnp(w,loc)}
zająć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zająć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zająć się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
zająć się: perf: subj{np(str)} + {prepnp(od,gen)}
zajmować: imperf: subj{np(str)} + obj{lexnp(str,_,'miejsce',atr)} + {prepnp(w,loc)}
zajmować: imperf: subj{np(str)} + obj{lexnp(str,_,'pozycja',atr)} + {prepnp(w,loc)}
zajmować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zajmować: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zajmować się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,żeby)}
zajrzeć: perf: subj{np(str)} + {cp(int)}
zajrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {prepnp(przez,acc)}
zajrzeć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zajrzeć: perf: subj{np(str)} + {prepnp(na,acc)}
zajrzeć: perf: subj{np(str)} + {xp(adl)}
zakazać: perf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakazywać: imperf: subj{np(str)} + obj,controllee{np(gen); cp(żeby); ncp(gen,żeby); infp(_)} + controller{np(dat)}
zakląć: perf: subj,controller{np(str)} + controllee{xp(mod)}
zakląć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zakląć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zakląć: perf: subj{np(str)} + obj{np(str)} + {or}
zakląć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zakląć: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zakląć się: perf: subj{np(str)} + {np(inst)} + {cp(że)}
zakląć się: perf: subj{np(str)} + {or}
zakląć się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zaklinać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(że)}
zaklinać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zaklinać: imperf: subj{np(str)} + obj{np(str)} + {or}
zaklinać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaklinać się: imperf: subj{np(str)} + {np(inst)} + {cp(że)}
zaklinać się: imperf: subj{np(str)} + {or}
zaklinać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zakładać: imperf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)}
zakładać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zakładać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zakładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zakładać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
zakładać: imperf: subj{np(str)} + {or}
zakładać się: imperf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(z,inst)}
zakładać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(int)}
zakładać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zakładać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {prepncp(o,acc,int)}
zakłócać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zakłócać się: imperf: subj{np(str)} + {np(dat)}
zakłócić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zakłócić się: perf: subj{np(str)} + {np(dat)}
zakochać się: perf: subj{np(str)} + {prepnp(w,loc)}
zakomunikować: perf: subj{np(str)} + {np(dat)} + {or}
zakomunikować: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zakomunikować: perf: subj{np(str)} + obj{cp(int)} + {np(dat)}
zakomunikować: perf: subj{np(str)} + obj{np(str); cp(że); ncp(str,że)} + {np(dat)}
zakończyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zakończyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że); ncp(inst,żeby)}
zakończyć: perf: subj{np(str)} + obj{np(str)} + {or}
zakończyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zakończyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zakończyć: perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zakończyć się: perf: subj,controller{np(str)} + controllee{xp(mod)}
zakończyć się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zakończyć się: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zakończyć się: perf: subj{np(str)} + {xp(locat)}
zakończyć się: perf: subj{np(str)} + {xp(temp)}
zakrawać: imperf: subj{cp(int)} + {prepnp(na,acc)}
zakrawać: imperf: subj{cp(że)} + {prepnp(na,acc)}
zakrawać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {prepnp(na,acc)}
zakręcić: perf: subj{np(str)} + {np(dat)} + {np(str)}
zakręcić: perf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,sg,'głowa',atr)}
zakręcić: perf: subj{np(str)} + {np(inst)}
zakręcić: perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zakręcić: perf: subj{np(str)} + obj{np(str)}
zakręcić się: perf: {np(dat)} + {preplexnp(w,loc,sg,'głowa',atr)}
zakręcić się: perf: subj{np(str)} + {or}
zakręcić się: perf: subj{np(str)} + {prepnp(koło,gen)}
zakręcić się: perf: subj{np(str)} + {prepnp(na,loc)}
zakręcić się: perf: subj{np(str)} + {prepnp(wokół,gen)}
zakręcić się: perf: subj{np(str)} + {xp(locat)}
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)}
zakwestionować: perf: subj{np(str)} + {cp(jakoby)}
zakwestionować: perf: subj{np(str)} + obj{cp(int)}
zakwestionować: perf: subj{np(str)} + obj{cp(że)}
zakwestionować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zakwitnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zakwitnąć: perf: subj{np(str)} + {prepnp(w,loc)}
zalać: perf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'sadło',natr)} + {preplexnp(za,acc,sg,'skóra',natr)}
zalać: perf: subj{np(str)} + {np(inst)} + {refl}
zalać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalać się: perf: subj{np(str)} + {np(inst)}
zalać się: perf: subj{np(str)} + {prepnp(w,acc)}
zalec: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zalec: perf: subj{np(str)} + {np(inst)}
zalec: perf: subj{np(str)} + {np(str)}
zalec: perf: subj{np(str)} + {prepnp(między,inst)}
zalec: perf: subj{np(str)} + {prepnp(w,loc)}
zalecać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zalecać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zalecać: imperf: subj{np(str)} + {np(dat)} + {or}
zalecać: imperf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
zalecać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zalecać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zalecić: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zalecić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zalecić: perf: subj{np(str)} + {np(dat)} + {or}
zalecić: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
zalecić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zalegać: imperf: subj{np(str)} + {np(dat)} + {np(str)}
zalegać: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
zalegać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(za,acc)}
zalegać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {prepnp(z,inst)}
zalegać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zalegać: imperf: subj{np(str)} + {np(inst)}
zalegać: imperf: subj{np(str)} + {np(str)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
zalegać: imperf: subj{np(str)} + {prepnp(między,inst)}
zalegać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(wobec,gen)} + {prepnp(za,acc)}
zalegać: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(wobec,gen)} + {prepnp(z,inst)}
zalegać: imperf: subj{np(str)} + {prepnp(w,loc)}
zalewać: imperf: subj{np(str)} + {cp(że)}
zalewać: imperf: subj{np(str)} + {np(dat)} + {lexnp(gen,sg,'sadło',natr)} + {preplexnp(za,acc,sg,'skóra',natr)}
zalewać: imperf: subj{np(str)} + {np(inst)} + {refl}
zalewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zalewać się: imperf: subj{np(str)} + {np(inst)}
zalewać się: imperf: subj{np(str)} + {prepnp(w,acc)}
zależeć: imperf: {np(dat)} + {prepnp(na,loc); prepncp(na,loc,żeby)}
zależeć: imperf: subj{cp(int)} + {prepnp(od,gen); prepncp(od,gen,int)}
zależeć: imperf: subj{np(str); ncp(str,int)} + {prepnp(od,gen); prepncp(od,gen,int)}
zależeć: perf: subj{np(str)} + {np(str)}
załamać: perf: subj{cp(gdy)} + {np(str)}
załamać: perf: subj{cp(int)} + {np(str)}
załamać: perf: subj{cp(jak)} + {np(str)}
załamać: perf: subj{cp(jeśli)} + {np(str)}
załamać: perf: subj{cp(kiedy)} + {np(str)}
załamać: perf: subj{cp(że)} + {np(str)}
załamać: perf: subj{np(str)} + {cp(int)} + {lexnp(str,pl,'ręka',natr)}
załamać: perf: subj{np(str)} + {cp(że)} + {lexnp(str,pl,'ręka',natr)}
załamać: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
załamać: perf: subj{np(str)} + obj{np(str)}
załamać: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {lexnp(str,pl,'ręka',natr)}
załamać się: perf: subj{np(str)} + {cp(int)}
załamać się: perf: subj{np(str)} + {cp(że)}
załamać się: perf: subj{np(str)} + {np(dat)}
załamać się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
załamać się: perf: subj{np(str)} + {prepnp(pod,inst)}
załamywać: imperf: subj{cp(gdy)} + {np(str)}
załamywać: imperf: subj{cp(int)} + {np(str)}
załamywać: imperf: subj{cp(jak)} + {np(str)}
załamywać: imperf: subj{cp(jeśli)} + {np(str)}
załamywać: imperf: subj{cp(kiedy)} + {np(str)}
załamywać: imperf: subj{cp(że)} + {np(str)}
załamywać: imperf: subj{np(str)} + {cp(int)} + {lexnp(str,pl,'ręka',natr)}
załamywać: imperf: subj{np(str)} + {cp(że)} + {lexnp(str,pl,'ręka',natr)}
załamywać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
załamywać: imperf: subj{np(str)} + obj{np(str)}
załamywać: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)} + {lexnp(str,pl,'ręka',natr)}
załamywać się: imperf: subj{np(str)} + {cp(int)}
załamywać się: imperf: subj{np(str)} + {cp(że)}
załamywać się: imperf: subj{np(str)} + {np(dat)}
załamywać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
załamywać się: imperf: subj{np(str)} + {prepnp(pod,inst)}
załatwiać: imperf: subj{np(str)} + {np(inst)} + {refl}
załatwiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
załatwiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
załatwiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
załatwiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
załatwiać się: imperf: subj{np(str)} + {prepnp(do,gen)}
załatwiać się: imperf: subj{np(str)} + {prepnp(w,acc)}
załatwiać się: imperf: subj{np(str)} + {prepnp(z,inst)}
załatwić: perf: subj{np(str)} + {np(inst)} + {refl}
załatwić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(od,gen)}
załatwić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
załatwić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
załatwić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
załatwić się: perf: subj{np(str)} + {prepnp(do,gen)}
załatwić się: perf: subj{np(str)} + {prepnp(w,acc)}
załatwić się: perf: subj{np(str)} + {prepnp(z,inst)}
założyć: perf: subj{np(str)} + obj{cp(że); ncp(str,że)}
założyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
założyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
założyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
założyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc)}
założyć się: perf: subj{np(str)} + {cp(int)}
założyć się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,że)} + {prepnp(z,inst)}
założyć się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zamarznąć: perf: subj{np(str)}
zamarzyć: perf: subj,controller{np(str)} + controllee{infp(_)}
zamarzyć: perf: subj{np(str)} + {cp(że)}
zamarzyć: perf: subj{np(str)} + {or}
zamarzyć: perf: subj{np(str)} + {prepnp(o,loc); cp(żeby); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zamarzyć się: perf: subj,controllee{infp(_)} + controller{np(dat)}
zamarzyć się: perf: subj{cp(żeby)} + {np(dat)}
zamarzyć się: perf: subj{cp(że)} + {np(dat)}
zamarzyć się: perf: subj{np(str)} + {np(dat)}
zamawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(u,gen); xp(locat)}
zamawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {prepnp(u,gen)}
zamawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zamawiać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zameldować: perf: subj{np(str)} + {np(dat)} + {cp(int)}
zameldować: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zameldować: perf: subj{np(str)} + {np(dat)} + {or}
zameldować: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,że)}
zameldować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zameldować: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zameldować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zameldować: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zameldować: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zameldować: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,loc)}
zameldować się: perf: subj{np(str)} + {np(dat)}
zameldować się: perf: subj{np(str)} + {prepnp(do,gen)}
zameldować się: perf: subj{np(str)} + {prepnp(na,acc)}
zameldować się: perf: subj{np(str)} + {prepnp(u,gen)}
zameldować się: perf: subj{np(str)} + {xp(locat)}
zamierać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamierać: imperf: subj{np(str)} + {prepnp(w,loc)}
zamierać: imperf: subj{np(str)} + {prepnp(z,gen)}
zamierzać: imperf: subj,controller{np(str)} + controllee{infp(_)}
zamierzać: imperf: subj{np(str)} + {nonch}
zamierzać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zamierzyć: perf: subj,controller{np(str)} + controllee{infp(_)}
zamierzyć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zamierzyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zamieszczać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamieszkać: perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)}
zamieszkać: perf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zamieszkiwać: imperf: subj{np(str)} + obj{np(str)}
zamieszkiwać: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(z,inst)}
zamieszkiwać: imperf: subj{np(str)} + {prepnp(z,inst)} + {xp(locat)}
zamieścić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamknąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamknąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
zamknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zamknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
zamknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zamknąć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamknąć: perf: subj{np(str)} + {xp(locat)} + {refl}
zamknąć się: perf: subj{np(str)} + {np(dat)}
zamknąć się: perf: subj{np(str)} + {np(inst)}
zamknąć się: perf: subj{np(str)} + {prepnp(dla,gen)}
zamknąć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(w,loc)}
zamknąć się: perf: subj{np(str)} + {prepnp(za,inst)}
zamontować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
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)} + {prepnp(u,gen)}
zamówić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zamówić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zamrzeć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zamrzeć: perf: subj{np(str)} + {prepnp(w,loc)}
zamrzeć: perf: subj{np(str)} + {prepnp(z,gen)}
zamykać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zamykać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {preplexnp(przed,inst,sg,'nos',natr)}
zamykać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zamykać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
zamykać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zamykać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zamykać: imperf: subj{np(str)} + {xp(locat)} + {refl}
zamykać się: imperf: subj{np(str)} + {np(dat)}
zamykać się: imperf: subj{np(str)} + {np(inst)}
zamykać się: imperf: subj{np(str)} + {prepnp(dla,gen)}
zamykać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(w,loc)}
zamykać się: imperf: subj{np(str)} + {prepnp(za,inst)}
zamyślać: imperf: subj,controller{np(str)} + controllee{infp(_)}
zamyślać: imperf: subj{np(str)} + {cp(że)}
zamyślać: imperf: subj{np(str)} + obj{np(str)}
zamyślać: imperf: subj{np(str)} + {prepnp(o,loc)}
zamyślać się: imperf: subj{np(str)} + {comprepnp(na temat)}
zamyślać się: imperf: subj{np(str)} + {cp(int)}
zamyślać się: imperf: subj{np(str)} + {cp(że)}
zamyślać się: imperf: subj{np(str)} + {or}
zamyślać się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zamyślić: perf: subj,controller{np(str)} + controllee{infp(_)}
zamyślić: perf: subj{np(str)} + {cp(że)}
zamyślić: perf: subj{np(str)} + obj{np(str)}
zamyślić: perf: subj{np(str)} + {prepnp(o,loc)}
zamyślić się: perf: subj{np(str)} + {comprepnp(na temat)}
zamyślić się: perf: subj{np(str)} + {cp(int)}
zamyślić się: perf: subj{np(str)} + {cp(że)}
zamyślić się: perf: subj{np(str)} + {or}
zamyślić się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zaniechać: perf: subj{np(str)} + obj{np(gen)}
zaniedbać: perf: subj,controller{np(str)} + controllee{infp(_)}
zaniedbać: perf: subj{np(str)} + obj{np(gen)}
zaniedbać: perf: subj{np(str)} + obj{np(str)}
zaniedbać się: perf: subj{np(str)} + {prepnp(w,loc)}
zaniedbywać: imperf: subj,controller{np(str)} + controllee{infp(_)}
zaniedbywać: imperf: subj{np(str)} + obj{np(gen)}
zaniedbywać: imperf: subj{np(str)} + obj{np(str)}
zaniedbywać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zaniepokoić: perf: subj{cp(gdy)} + {np(str)}
zaniepokoić: perf: subj{cp(jak)} + {np(str)}
zaniepokoić: perf: subj{cp(jeśli)} + {np(str)}
zaniepokoić: perf: subj{cp(kiedy)} + {np(str)}
zaniepokoić: perf: subj{cp(że)} + {np(str)}
zaniepokoić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zaniepokoić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zaniepokoić się: perf: subj{np(str)} + {cp(int)}
zaniepokoić się: perf: subj{np(str)} + {cp(że)}
zaniepokoić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zaniepokoić się: perf: subj{np(str)} + {or}
zaniepokoić się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zanieść: perf: {np(inst)} + {np(str)}
zanieść: perf: {np(inst)} + {xp(abl)}
zanieść: perf: {np(str)} + {xp(adl)}
zanieść: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
zanieść: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
zanieść: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zanieść się: perf: {np(inst)} + {xp(abl)}
zanieść się: perf: {prepnp(na,acc); prepncp(na,acc,że)}
zanieść się: perf: subj{np(str)} + {np(inst)}
zanieść się: perf: subj{np(str)} + {prepnp(od,gen)}
zanosić: imperf: {np(inst)} + {np(str)}
zanosić: imperf: {np(inst)} + {xp(abl)}
zanosić: imperf: {np(str)} + {xp(adl)}
zanosić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)} + {xp(adl)}
zanosić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {xp(adl)}
zanosić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zanosić się: imperf: {cp(że)}
zanosić się: imperf: {cp(żeby2)}
zanosić się: imperf: {np(inst)} + {xp(abl)}
zanosić się: imperf: {prepncp(na,acc,żeby2)}
zanosić się: imperf: {prepnp(na,acc); prepncp(na,acc,że)}
zanosić się: imperf: subj{np(str)} + {np(inst)}
zanosić się: imperf: subj{np(str)} + {prepnp(od,gen)}
zanosić się: imperf: subj{np(str)} + {prepnp(z,gen)}
zanurzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
zanurzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
zanurzać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zanurzać: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)} + {refl}
zanurzać: imperf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)} + {refl}
zanurzać: imperf: subj{np(str)} + {xp(adl)} + {refl}
zanurzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)}
zanurzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)}
zanurzyć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zanurzyć: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(w,loc)} + {refl}
zanurzyć: perf: subj{np(str)} + {prepnp(po,acc)} + {prepnp(w,loc)} + {refl}
zanurzyć: perf: subj{np(str)} + {xp(adl)} + {refl}
zaobserwować: perf: subj{np(str)} + {cp(int)}
zaobserwować: perf: subj{np(str)} + {cp(jak)}
zaobserwować: perf: subj{np(str)} + {cp(że)}
zaobserwować: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zaoferować: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zaoferować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {or}
zaoferować się: perf: subj,controller{np(str)} + controllee{infp(_)}
zaoferować się: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zaoferować się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zaopatrywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaopatrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaopatrywać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaopatrywać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zaopatrywać się: imperf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(w,acc)}
zaopatrywać się: imperf: subj{np(str)} + {prepnp(w,acc)} + {xp(locat)}
zaopatrzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaopatrzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zaopatrzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaopatrzyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(w,acc)}
zaopatrzyć się: perf: subj{np(str)} + {prepnp(u,gen)} + {prepnp(w,acc)}
zaopatrzyć się: perf: subj{np(str)} + {prepnp(w,acc)} + {xp(locat)}
zaopiniować: perf: subj{np(str)} + {cp(int)}
zaopiniować: perf: subj{np(str)} + {cp(że)}
zaopiniować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zaopiniować: perf: subj{np(str)} + {or}
zaoszczędzić: perf: subj{np(str)} + obj{np(part); ncp(part,że)} + {np(dat)}
zaoszczędzić: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zaoszczędzić: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,loc); prepncp(na,loc,że)}
zaowocować: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zapadać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zapadać: imperf: subj{np(str)} + {preplexnp(na,loc,sg,'zdrowie',natr)}
zapadać: imperf: subj{np(str)} + {prepnp(na,acc)}
zapadać: imperf: subj{np(str)} + {prepnp(w,loc)}
zapadać: imperf: subj{np(str)} + {xp(adl)}
zapadać: imperf: subj{np(str)} + {xp(locat)}
zapadać się: imperf: subj{np(str)} + {preplexnp(pod,acc,sg,'ziemia',natr)}
zapadać się: imperf: subj{np(str)} + {prepnp(pod,inst)}
zapadać się: imperf: subj{np(str)} + {prepnp(w,acc)}
zapadać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zapakować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapakować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapakować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zapakować: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zapakować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapakować: imperf: subj{np(str)} + {xp(adl)} + {refl}
zapakować się: imperf: subj{np(str)} + {prepnp(do,gen)}
zapakować się: imperf: subj{np(str)} + {prepnp(na,acc)}
zapakować się: imperf: subj{np(str)} + {prepnp(w,acc)}
zapalać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zapalać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zapalać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
zapalać się: imperf: subj{np(str)} + {np(inst)}
zapalać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zapalać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zapalić: perf: subj{np(str)} + {np(inst)} + {np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zapalić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapalić: perf: subj{np(str)} + obj{np(str)} + {prepnp(od,gen)}
zapalić się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen); prepncp(od,gen,że)}
zapalić się: perf: subj{np(str)} + {np(inst)}
zapalić się: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zapalić się: perf: subj{np(str)} + {prepnp(w,loc)}
zapamiętać: perf: subj{np(str)} + {cp(int)}
zapamiętać: perf: subj{np(str)} + {cp(jak)}
zapamiętać: perf: subj{np(str)} + {cp(że)}
zapamiętać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
zapamiętać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapamiętać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zapamiętać: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)}
zapamiętać: perf: subj{np(str)} + {or}
zapamiętać się: perf: subj{np(str)} + {prepnp(w,loc)}
zapanować: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że); prepncp(nad,inst,żeby)}
zapanować: perf: subj{np(str)} + {xp(locat)}
zaparkować: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaparkować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zaparzyć: perf: subj{np(str)} + {np(str)} + {prepnp(w,acc)}
zaparzyć: perf: subj{np(str)} + obj{np(part)} + {np(dat)} + {prepnp(w,loc)}
zaparzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaparzyć się: perf: subj{np(str)} + {prepnp(w,loc)}
zapaść: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zapaść: perf: subj{np(str)} + {preplexnp(na,loc,sg,'zdrowie',natr)}
zapaść: perf: subj{np(str)} + {prepnp(na,acc)}
zapaść: perf: subj{np(str)} + {prepnp(w,loc)}
zapaść: perf: subj{np(str)} + {xp(adl)}
zapaść: perf: subj{np(str)} + {xp(locat)}
zapaść się: perf: subj{np(str)} + {preplexnp(pod,acc,sg,'ziemia',natr)}
zapaść się: perf: subj{np(str)} + {prepnp(pod,inst)}
zapaść się: perf: subj{np(str)} + {prepnp(w,acc)}
zapaść się: perf: subj{np(str)} + {prepnp(w,loc)}
zapełniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapełniać się: imperf: subj{np(str)} + {np(inst)}
zapełnić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapełnić się: perf: subj{np(str)} + {np(inst)}
zapewniać: imperf: subj{np(str)} + obj{ncp(str,żeby)} + {np(dat)}
zapewniać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
zapewniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); cp(że); prepncp(o,loc,że)}
zapewnić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zapewnić: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zapewnić: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zapewnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,loc); prepncp(o,loc,że)}
zapiąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zapiąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapiąć: perf: subj{np(str)} + {refl}
zapiąć się: perf: subj{np(str)} + {prepnp(na,acc)}
zapisać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zapisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapisać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapisać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zapisać się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zapisać się: perf: subj{np(str)} + {prepnp(do,gen)}
zapisać się: perf: subj{np(str)} + {prepnp(na,acc)}
zaplanować: perf: subj,controller{np(str)} + controllee{infp(_)}
zaplanować: perf: subj{np(str)} + {cp(int)}
zaplanować: perf: subj{np(str)} + {cp(żeby)}
zaplanować: perf: subj{np(str)} + obj{cp(że)}
zaplanować: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,acc)}
zaplanować: perf: subj{np(str)} + {or}
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)}
zapłacić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zapłonąć: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapłonąć: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zapłonąć: perf: subj{np(str)} + {prepnp(od,gen)}
zapobiec: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zapobiec: perf: subj{np(str)} + {np(inst)} + {ncp(dat,że)}
zapobiec: perf: subj{np(str)} + {np(inst)} + {ncp(dat,żeby)}
zapobiegać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zapobiegać: imperf: subj{np(str)} + {np(inst)} + {ncp(dat,że)}
zapobiegać: imperf: subj{np(str)} + {np(inst)} + {ncp(dat,żeby)}
zapominać: imperf: subj,controller{np(str)} + controllee{infp(_)}
zapominać: imperf: subj{np(str)} + {np(gen)}
zapominać: imperf: subj{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)} + {np(dat)}
zapominać: imperf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(jak); cp(że); prepncp(o,loc,int); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zapominać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zapomnieć: perf: subj,controller{np(str)} + controllee{infp(_)}
zapomnieć: perf: subj{np(str)} + {np(gen)}
zapomnieć: perf: subj{np(str)} + obj{np(str); ncp(str,jak); ncp(str,że)} + {np(dat)}
zapomnieć: perf: subj{np(str)} + {prepnp(o,loc); cp(int); cp(jak); cp(że); prepncp(o,loc,jak); prepncp(o,loc,że); prepncp(o,loc,żeby)}
zapomnieć się: perf: subj{np(str)} + {prepnp(w,loc)}
zapowiadać: imperf: subj{np(str)} + {ncp(str,żeby2)}
zapowiadać: imperf: subj{np(str)} + {np(dat)} + {or}
zapowiadać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiadać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zapowiadać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {np(dat)}
zapowiadać się: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiadać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zapowiadać się: imperf: subj{cp(że)}
zapowiadać się: imperf: subj{cp(żeby2)}
zapowiadać się: imperf: subj{np(str)} + {advp(misc)}
zapowiadać się: imperf: subj{np(str)} + {prepncp(na,acc,żeby2)}
zapowiadać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zapowiadać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
zapowiadać się: imperf: subj{prepncp(na,acc,żeby2)}
zapowiedzieć: perf: subj{np(str)} + {np(dat)} + {or}
zapowiedzieć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiedzieć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zapowiedzieć: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); cp(żeby); ncp(str,że)} + {np(dat)}
zapowiedzieć się: perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)}
zapowiedzieć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zapowiedzieć się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
zapoznać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapoznać się: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapoznawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapoznawać się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zapragnąć: perf: subj,controller{np(str)} + controllee{cp(żeby); infp(_)}
zapragnąć: perf: subj{np(str)} + {np(gen); ncp(gen,żeby)}
zapraszać: imperf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zapraszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zapraszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zapraszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {xp(adl)}
zapraszać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)} + {refl}
zaproponować: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zaproponować: perf: subj{np(str)} + {np(dat)} + {or}
zaproponować: perf: subj{np(str)} + {np(str)} + {prepnp(na,acc)}
zaproponować: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)}
zaproponować: perf: subj{np(str)} + obj{cp(że)} + {np(dat)}
zaproponować: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zaprosić: perf: subj{np(str)} + obj{np(str)} + {cp(żeby)}
zaprosić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zaprosić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zaprosić: perf: subj{np(str)} + {or}
zaprosić: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)} + {refl}
zaprotestować: perf: subj{np(str)} + {cp(że)}
zaprotestować: perf: subj{np(str)} + {np(inst)}
zaprotestować: perf: subj{np(str)} + {or}
zaprotestować: perf: subj{np(str)} + {prepncp(przeciw,dat,żeby)}
zaprotestować: perf: subj{np(str)} + {prepnp(przeciw,dat); prepncp(przeciw,dat,że)}
zapuszczać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zapuszczać: imperf: subj{np(str)} + {prepnp(przez,acc)} + {lexnp(str,sg,'żuraw',natr)}
zapuszczać: imperf: subj{np(str)} + {xp(locat)} + {lexnp(str,pl,'korzeń',natr)}
zapuszczać się: imperf: subj{np(str)} + {prepnp(w,acc)}
zapuszczać się: imperf: subj{np(str)} + {xp(adl)}
zapuścić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(adl)}
zapuścić: perf: subj{np(str)} + {prepnp(przez,acc)} + {lexnp(str,sg,'żuraw',natr)}
zapuścić: perf: subj{np(str)} + {xp(locat)} + {lexnp(str,pl,'korzeń',natr)}
zapuścić się: perf: subj{np(str)} + {prepnp(w,acc)}
zapuścić się: perf: subj{np(str)} + {xp(adl)}
zapytać: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zapytać: perf: subj{np(str)} + obj{np(str)} + {or}
zapytać: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int)}
zapytać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zapytać się: perf: subj{np(str)} + {np(gen)} + {cp(int)}
zapytać się: perf: subj{np(str)} + {np(gen)} + {prepnp(o,acc); prepncp(o,acc,int)}
zapytać się: perf: subj{np(str)} + {or}
zarabiać: imperf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zarabiać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarabiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zarabiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zarastać: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zarastać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarastać się: imperf: subj{np(str)} + {np(dat)}
zareagować: perf: subj{np(str)} + controller{prepnp(na,acc); prepncp(na,acc,gdy); prepncp(na,acc,jak); prepncp(na,acc,jakby); prepncp(na,acc,kiedy); prepncp(na,acc,że); prepncp(na,acc,żeby)} + controllee{xp(mod)}
zareagować: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(na,acc)}
zareagować: perf: subj{np(str)} + {prepnp(z,inst)}
zarejestrować: perf: subj{np(str)} + {cp(int)}
zarejestrować: perf: subj{np(str)} + {cp(jak)}
zarejestrować: perf: subj{np(str)} + {cp(że)}
zarejestrować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zarejestrować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarejestrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zarejestrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zarejestrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zarejestrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zarejestrować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zarejestrować: perf: subj{np(str)} + {or}
zarejestrować się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zarejestrować się: perf: subj{np(str)} + {prepnp(do,gen)}
zarejestrować się: perf: subj{np(str)} + {prepnp(na,acc)}
zarejestrować się: perf: subj{np(str)} + {prepnp(u,gen)}
zarejestrować się: perf: subj{np(str)} + {xp(locat)}
zarezerwować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarezerwować: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zarezerwować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zarobić: perf: subj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zarobić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zarobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zarobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zarobić: perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(po,loc)}
zarobić: perf: subj{np(str)} + {prepnp(od,gen)} + {prepnp(w,acc)}
zarosnąć: perf: subj{np(str)} + {np(dat)} + {np(inst)}
zarosnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zarosnąć się: perf: subj{np(str)} + {np(dat)}
zaryzykować: perf: subj{np(str)} + {cp(że)}
zaryzykować: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zaryzykować: perf: subj{np(str)} + {np(str); ncp(str,że)}
zarządzać: imperf: subj{np(str)} + {advp(pron)}
zarządzać: imperf: subj{np(str)} + {cp(że)}
zarządzać: imperf: subj{np(str)} + {cp(żeby)}
zarządzać: imperf: subj{np(str)} + obj{np(inst)}
zarządzać: imperf: subj{np(str)} + obj{np(str)}
zarządzać: imperf: subj{np(str)} + {or}
zarządzić: perf: subj{np(str)} + {advp(pron)}
zarządzić: perf: subj{np(str)} + {cp(że)}
zarządzić: perf: subj{np(str)} + {cp(żeby)}
zarządzić: perf: subj{np(str)} + obj{np(inst)}
zarządzić: perf: subj{np(str)} + obj{np(str)}
zarządzić: perf: subj{np(str)} + {or}
zarzucać: imperf: subj{np(str)} + obj{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)}
zasiadać: imperf: subj{np(str)} + {prepnp(do,gen)}
zasiadać: imperf: subj{np(str)} + {prepnp(w,loc)}
zasiadać: imperf: subj{np(str)} + {xp(locat)}
zasiąść: perf: subj{np(str)} + {prepnp(do,gen)}
zasiąść: perf: subj{np(str)} + {prepnp(w,loc)}
zasiąść: perf: subj{np(str)} + {xp(locat)}
zasiedlić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zasilać: imperf: subj{np(str)} + {np(inst)} + {refl}
zasilać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasilać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zasilać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zasilić: perf: subj{np(str)} + {np(inst)} + {refl}
zasilić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zasilić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zasilić: perf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zaskarżyć: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zaskarżyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc)}
zaskarżyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)} + {prepnp(za,acc); prepncp(za,acc,że)}
zasłaniać: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
zasłaniać: imperf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
zasłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
zasłaniać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
zasłonić: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(przed,inst)} + {refl}
zasłonić: perf: subj{np(str)} + {np(inst)} + {prepnp(od,gen)} + {refl}
zasłonić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(od,gen)}
zasłonić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(przed,inst)}
zasługiwać: imperf: subj{np(str)} + {cp(żeby)}
zasługiwać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zasługiwać się: imperf: subj{np(str)} + {np(dat)} + {np(inst)}
zasnąć: perf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
zasnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc); 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)}
zaspokajać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaspokajać się: imperf: subj{np(str)} + {np(inst)}
zaspokoić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaspokoić się: perf: subj{np(str)} + {np(inst)}
zastać: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zastać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastać: perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zastać się: perf: subj{np(str)} + {prepnp(w,loc)}
zastanawiać: imperf: subj{cp(int)} + {np(str)}
zastanawiać: imperf: subj{cp(że)} + {np(str)}
zastanawiać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zastanawiać się: imperf: subj{np(str)} + {cp(że)}
zastanawiać się: imperf: subj{np(str)} + {or}
zastanawiać się: imperf: subj{np(str)} + {prepnp(nad,inst); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zastanowić: perf: subj{cp(int)} + {np(str)}
zastanowić: perf: subj{cp(że)} + {np(str)}
zastanowić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zastanowić się: perf: subj{np(str)} + {cp(że)}
zastanowić się: perf: subj{np(str)} + {or}
zastanowić się: perf: subj{np(str)} + {prepnp(nad,inst); cp(int); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zastawać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(pred)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(nad,inst)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastawać: imperf: subj{np(str)} + obj{np(str)} + {xp(temp)}
zastawać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zastąpić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zastąpić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastąpić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastępować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zastępować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastępować: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zastosować: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zastosować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zastosować się: perf: subj{np(str)} + {prepnp(do,gen)}
zastrzec: perf: subj{np(str)} + {cp(żeby)} + {lexnp(dat,_,'siebie',natr)}
zastrzec: perf: subj{np(str)} + obj{cp(że)} + {lexnp(dat,_,'siebie',natr)}
zastrzec: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {lexnp(dat,_,'siebie',natr)}
zastrzec: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zastrzec się: perf: subj{np(str)} + {cp(że)}
zastrzec się: perf: subj{np(str)} + {or}
zastrzec się: perf: subj{np(str)} + {prepnp(przeciw,dat)}
zastrzelić: perf: subj{np(str)} + {np(inst)} + {refl}
zastrzelić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zastrzelić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zastrzelić: perf: subj{np(str)} + {prepnp(z,gen)} + {refl}
zasugerować: perf: subj{np(str)} + {np(dat)} + {or}
zasugerować: perf: subj{np(str)} + obj{cp(int)} + {np(dat)} + {np(inst)}
zasugerować: perf: subj{np(str)} + obj{cp(jakoby)} + {np(dat)} + {np(inst)}
zasugerować: perf: subj{np(str)} + obj{cp(żeby)} + {np(dat)} + {np(inst)}
zasugerować: perf: subj{np(str)} + obj{cp(że)} + {np(dat)} + {np(inst)}
zasugerować: perf: subj{np(str)} + obj{np(str); ncp(str,że); ncp(str,żeby)} + {np(dat)} + {np(inst)}
zasugerować się: perf: subj{np(str)} + {cp(że)}
zasugerować się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zasypiać: imperf: subj{np(str)} + {lexnp(inst,sg,'sen',atr)}
zasypiać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc); xp(locat)}
zasypiać: imperf: subj{np(str)} + obj{lexnp(str,pl,'gruszka',natr)} + {preplexnp(w,loc,sg,'popiół',natr)}
zasypiać: imperf: subj{np(str)} + {prepnp(do,gen)}
zasypiać: imperf: subj{np(str)} + {prepnp(na,acc)}
zasypiać: imperf: subj{np(str)} + {prepnp(nad,inst)}
zasypiać: imperf: subj{np(str)} + {prepnp(w,loc)}
zasypiać: imperf: subj{np(str)} + {prepnp(z,gen)}
zaszkodzić: perf: subj,controllee{infp(_)} + controller{np(dat)}
zaszkodzić: perf: subj{cp(gdy)} + {np(dat)}
zaszkodzić: perf: subj{cp(jak)} + {np(dat)}
zaszkodzić: perf: subj{cp(jeśli)} + {np(dat)}
zaszkodzić: perf: subj{cp(kiedy)} + {np(dat)}
zaszkodzić: perf: subj{cp(że)} + {np(dat)}
zaszkodzić: perf: subj{np(str); ncp(str,że)} + {np(dat)}
zaszkodzić: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zaszkodzić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zaszkodzić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
zaszyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(pod,acc)}
zaszyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zaszyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zaszyć się: perf: subj{np(str)} + {prepnp(w,acc)}
zaszyć się: perf: subj{np(str)} + {xp(locat)}
zaśmiać się: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)} + {or}
zaśmiać się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {or}
zaśpiewać: perf: subj{np(str)} + {cp(że)}
zaśpiewać: perf: subj{np(str)} + {np(dat)} + {np(str)} + {prepnp(za,acc)}
zaśpiewać: perf: subj{np(str)} + {np(dat)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zaśpiewać: perf: subj{np(str)} + {np(inst)} + {or}
zaśpiewać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zataczać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zataczać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zataczać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zataczać się: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zatelefonować: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(o,acc)} + {prepnp(od,gen); xp(abl)}
zatelefonować: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {comprepnp(w sprawie)}
zatelefonować: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {cp(int); cp(że); cp(żeby)}
zatelefonować: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(po,acc)}
zatelefonować: perf: subj{np(str)} + {prepnp(do,gen); xp(adl)} + {prepnp(od,gen); xp(abl)} + {prepnp(z,inst); prepncp(z,inst,że)}
zatoczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zatoczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zatoczyć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zatoczyć się: perf: subj{np(str)} + {np(dat)} + {xp(adl)}
zatroszczyć się: perf: subj{np(str)} + {cp(int)}
zatroszczyć się: perf: subj{np(str)} + {cp(że)}
zatroszczyć się: perf: subj{np(str)} + {cp(żeby)}
zatroszczyć się: perf: subj{np(str)} + {np(inst)}
zatroszczyć się: perf: subj{np(str)} + {or}
zatroszczyć się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że); prepncp(o,acc,żeby)}
zatruć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zatruć się: perf: subj{np(str)} + {np(inst)}
zatrudniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudniać: imperf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zatrudniać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatrudniać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatrudniać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudniać się: imperf: subj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatrudnić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudnić: perf: subj{np(str)} + obj{np(str)} + {advp(misc)}
zatrudnić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatrudnić: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatrudnić się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zatrudnić się: perf: subj{np(str)} + {prepnp(przy,loc); prepnp(u,gen); prepnp(w,loc)}
zatrzeć: perf: subj{np(str); ncp(str,że)} + obj{np(str); ncp(str,że)} + {np(inst)}
zatrzeć: perf: subj{np(str)} + {prepnp(na,acc)} + {lexnp(str,pl,'ręka',natr)}
zatrzeć się: perf: subj{np(str); ncp(str,że)} + {np(dat)}
zatrzymać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zatrzymać: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zatrzymać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zatrzymać się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zatrzymać się: perf: subj{np(str)} + {prepnp(na,loc)}
zatrzymać się: perf: subj{np(str)} + {prepnp(przy,loc); prepncp(przy,loc,int)}
zatrzymać się: perf: subj{np(str)} + {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,loc,int)}
zatrzymywać się: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
zatwierdzić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zatwierdzić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zatwierdzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zatwierdzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zatytułować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{or}
zatytułować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zaufać: perf: subj{np(str)} + {np(dat)} + {comprepnp(w kwestii)}
zaufać: perf: subj{np(str)} + {np(dat)} + {prepncp(w,acc,że)}
zaufać: perf: subj{np(str)} + {prepnp(w,loc)}
zauważać: imperf: subj{np(str)} + {cp(jak)}
zauważać: imperf: subj{np(str)} + obj{cp(int); cp(że)}
zauważać: imperf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zauważać: imperf: subj{np(str)} + {or}
zauważyć: perf: subj{np(str)} + {cp(jak)}
zauważyć: perf: subj{np(str)} + obj{cp(int); cp(że)}
zauważyć: perf: subj{np(str)} + obj{np(str); ncp(str,int); ncp(str,że)}
zauważyć: perf: subj{np(str)} + {or}
zawahać się: perf: subj,controller{np(str)} + controllee{infp(_)}
zawahać się: perf: subj{np(str)} + {cp(int)}
zawahać się: perf: subj{np(str)} + {cp(żeby)}
zawahać się: perf: subj{np(str)} + {cp(żeby2)}
zawahać się: perf: subj{np(str)} + {prepncp(nad,inst,żeby)}
zawahać się: perf: subj{np(str)} + {prepncp(przed,inst,żeby2)}
zawahać się: perf: subj{np(str)} + {prepnp(między,inst)}
zawahać się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int)}
zawahać się: perf: subj{np(str)} + {prepnp(przed,inst)}
zawalić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zawalić się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zawalić się: perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
zawdzięczać: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zawdzięczać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat); ncp(dat,że)}
zawetować: perf: subj{np(str)} + obj{np(str)}
zawiązać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawiązać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zawiązać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zawiązać się: perf: subj{np(str)} + {prepnp(między,inst)}
zawierać: imperf: subj{np(str)} + {np(str)}
zawierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawierać się: imperf: subj{np(str)} + {prepnp(między,inst)}
zawierać się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
zawiesić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawiesić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zawiesić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zawiesić: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawiesić: perf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zawiesić się: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zawieszać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawieszać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zawieszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zawieszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawieszać: imperf: subj{np(str)} + {prepnp(w,loc)} + {refl}
zawieszać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zawijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zawijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zawijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zawijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zawijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawijać: imperf: subj{np(str)} + {prepnp(w,acc)} + {refl}
zawijać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)}
zawijać się: imperf: subj{np(str)} + {prepnp(z,inst)}
zawijać się: imperf: subj{np(str)} + {xp(abl)}
zawijać się: imperf: subj{np(str)} + {xp(adl)}
zawijać się: imperf: subj{np(str)} + {xp(locat)}
zawinić: perf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zawinić: perf: subj{np(str)} + {np(dat)} + {np(str)}
zawinić: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc); prepncp(w,loc,że)}
zawinić: perf: subj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
zawinić: perf: subj{np(str)} + {np(inst)} + {prepnp(wobec,gen)}
zawinić: perf: subj{np(str)} + {prepnp(przeciw,dat)} + {nonch}
zawinić: perf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(w,loc)}
zawinić: perf: subj{np(str)} + {prepnp(przed,inst)} + {nonch}
zawinić: perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(wobec,gen)}
zawinić: perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(względem,gen)}
zawinić: perf: subj{np(str)} + {prepnp(wobec,gen)} + {nonch}
zawinić: perf: subj{np(str)} + {prepnp(względem,gen)} + {nonch}
zawisnąć: perf: subj{np(str)} + {prepnp(nad,inst)}
zawisnąć: perf: subj{np(str)} + {prepnp(na,loc)}
zawisnąć: perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(inst,sg,'wzrok',natr)}
zawisnąć: perf: subj{np(str)} + {prepnp(od,gen)}
zawisnąć: perf: subj{np(str)} + {prepnp(z,gen)}
zawisnąć: perf: subj{np(str)} + {xp(locat)}
zawitać: perf: subj{np(str)} + {prepnp(do,gen)}
zawitać: perf: subj{np(str)} + {xp(abl)}
zawitać: perf: subj{np(str)} + {xp(adl)}
zawitać: perf: subj{np(str)} + {xp(locat)}
zawładnąć: perf: subj{np(str)} + obj{np(inst)}
zawodzić: imperf: subj{np(str)} + {np(str)}
zawodzić: imperf: subj{np(str)} + obj{np(str)}
zawodzić: imperf: subj{np(str)} + {or}
zawodzić się: imperf: subj{np(str)} + {prepnp(na,loc)}
zawołać: imperf: subj{np(str)} + {np(inst)} + {or}
zawołać: imperf: subj{np(str)} + obj{np(str)}
zawołać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(int)}
zawołać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(że)}
zawołać: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zawołać: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
zawołać: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(żeby)}
zawołać: imperf: subj{np(str)} + {prepnp(na,acc)} + {or}
zawołać: imperf: subj{np(str)} + {prepnp(za,inst)} + {or}
zawracać: imperf: subj{np(str)} + {np(dat)} + {np(inst); ncp(inst,int); ncp(inst,że); ncp(inst,żeby)} + {np(str)}
zawracać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(w,loc,_,'głowa',natr)}
zawracać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zawracać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zawracać się: imperf: subj{np(str)}
zawrzeć: perf: subj{np(str)} + {np(inst)}
zawrzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zawrzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zawrzeć: perf: {xp(locat)}
zawrzeć się: perf: subj{np(str)} + {prepnp(między,inst)}
zawrzeć się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że); prepncp(w,loc,żeby)}
zazdrościć: imperf: subj{np(str)} + {np(dat)} + {np(gen); ncp(gen,że)}
zaznaczać: perf: subj{np(str)} + {cp(int)}
zaznaczać: perf: subj{np(str)} + {cp(że)}
zaznaczać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczać: perf: subj{np(str)} + {or}
zaznaczać się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczać się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zaznaczać się: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczyć: perf: subj{np(str)} + {cp(int)}
zaznaczyć: perf: subj{np(str)} + {cp(że)}
zaznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zaznaczyć: perf: subj{np(str)} + {or}
zaznaczyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zaznaczyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zaznaczyć się: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
zażądać: perf: subj{np(str)} + {np(gen)} + {prepnp(od,gen)}
zażądać: perf: subj{np(str)} + {prepnp(od,gen)} + {cp(żeby)}
zażądać: perf: subj{np(str)} + {prepnp(od,gen)} + {ncp(gen,żeby)}
zażyć: perf: subj{np(str)} + obj{np(gen)}
zażyć: perf: subj{np(str)} + obj{np(part)}
zażyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zażyć: perf: subj{np(str)} + obj{np(str)} + {preplexnp(z,gen,sg,'mańka',natr)}
zażywać: imperf: subj{np(str)} + {np(gen)}
zażywać: imperf: subj{np(str)} + obj{np(part)}
zażywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(z,gen,sg,'mańka',natr)}
zbadać: perf: subj{np(str)} + obj{cp(int)} + {np(inst)}
zbadać: perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(inst)}
zbadać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zbadać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zbadać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zbadać się: perf: subj{np(str)} + {prepnp(na,acc)}
zbadać się: perf: subj{np(str)} + {prepnp(u,gen)}
zbadać się: perf: subj{np(str)} + {xp(locat)}
zbić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'pantałyk',natr)}
zbić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'trop',natr)}
zbić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {fixed('na kwaśne jabłko')}
zbić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {preplexnp(na,acc,sg,'miazga',atr)}
zbić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
zbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)} + {lexnp(dat,_,'siebie',natr)}
zbić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zbić się: perf: subj{np(str)} + {prepnp(w,acc)}
zbiec: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zbiec: perf: subj{np(str)} + {prepnp(z,gen)}
zbiec: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zbiec się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'czas',natr)}
zbiec się: perf: subj{np(str)} + {xp(adl)}
zbiec się: perf: subj{np(str)} + {xp(locat)}
zbiegać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zbiegać: imperf: subj{np(str)} + {prepnp(z,gen)}
zbiegać: imperf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zbiegać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)} + {preplexnp(w,loc,sg,'czas',natr)}
zbiegać się: imperf: subj{np(str)} + {xp(adl)}
zbiegać się: imperf: subj{np(str)} + {xp(locat)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zbierać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zbierać się: imperf: {np(dat)} + {prepnp(na,acc)}
zbierać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
zbierać się: imperf: subj{E} + {prepnp(na,acc)}
zbierać się: imperf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,_,'siebie',natr)}
zbierać się: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zbierać się: imperf: subj{np(str)} + {prepnp(u,gen)}
zbierać się: imperf: subj{np(str)} + {prepnp(w,acc)}
zbierać się: imperf: subj{np(str)} + {xp(abl)}
zbierać się: imperf: subj{np(str)} + {xp(adl)}
zbierać się: imperf: subj{np(str)} + {xp(locat)}
zbijać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'pantałyk',natr)}
zbijać: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {preplexnp(z,gen,sg,'trop',natr)}
zbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,acc,że)}
zbijać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zbijać się: imperf: subj{np(str)} + {prepnp(w,acc)}
zbijać się: imperf: subj{np(str)} + {prepnp(z,gen)}
zbliżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zbliżać się: imperf: subj{np(str)} + {prepnp(do,gen)}
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)}
zburzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zburzyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zburzyć się: perf: subj{np(str)} + {np(dat)}
zburzyć się: perf: subj{np(str)} + {prepnp(w,loc)}
zdać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zdać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zdać: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zdać się: perf: subj,controller{cp(że)} + controllee{np(inst)} + {np(dat)}
zdać się: perf: subj,controller{E} + controllee{infp(imperf)}
zdać się: perf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
zdać się: perf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
zdać się: perf: subj{cp(że)} + {np(dat)}
zdać się: perf: subj{np(str)} + {prepnp(na,acc)}
zdarzać: imperf: subj{np(str)} + {cp(że)} + {xp(temp)}
zdarzać się: imperf: subj,controllee{infp(_)} + controller{np(dat)} + {xp(temp)}
zdarzać się: imperf: subj{cp(żeby)} + {np(dat)} + {xp(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,controllee{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)} + controllee{np(inst)} + {np(dat)}
zdawać się: imperf: subj,controller{E} + controllee{infp(imperf)}
zdawać się: imperf: subj,controller{np(str)} + controllee{adjp(pred)} + {np(dat)}
zdawać się: imperf: subj,controller{np(str)} + controllee{np(inst)} + {np(dat)}
zdawać się: imperf: subj{cp(że)} + {np(dat)}
zdawać się: imperf: subj{np(str)} + {prepnp(na,acc)}
zdążać: imperf: subj,controller{np(str)} + controllee{infp(_)}
zdążać: imperf: subj{np(str)} + {cp(żeby)}
zdążać: imperf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zdążać: imperf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zdążać: imperf: subj{np(str)} + {prepnp(za,inst)}
zdążać: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
zdążać: imperf: subj{np(str)} + {xp(adl)}
zdążyć: perf: subj,controller{np(str)} + controllee{infp(_)}
zdążyć: perf: subj{np(str)} + {prepnp(na,acc)} + {xp(adl)}
zdążyć: perf: subj{np(str)} + {prepnp(za,inst)}
zdążyć: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)}
zdechnąć: perf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
zdechnąć: perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zdechnąć: perf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',natr)}
zdechnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zdechnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zdechnąć: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdechnąć: perf: subj{np(str)} + {prepnp(za,acc)}
zdecydować: perf: subj,controller{np(str)} + controllee{infp(_)}
zdecydować: perf: subj{np(str)} + {comprepnp(w sprawie)}
zdecydować: perf: subj{np(str)} + {cp(int)}
zdecydować: perf: subj{np(str)} + {cp(że)}
zdecydować: perf: subj{np(str)} + {cp(żeby)}
zdecydować: perf: subj{np(str); ncp(str,że)} + {prepnp(o,loc); prepncp(o,loc,int); prepncp(o,loc,że)}
zdecydować: perf: subj{np(str)} + {or}
zdecydować: perf: subj{np(str)} + {prepncp(o,loc,żeby)}
zdecydować się: perf: subj,controller{np(str)} + controllee{infp(_)}
zdecydować się: perf: subj{np(str)} + {cp(int)}
zdecydować się: perf: subj{np(str)} + {cp(żeby)}
zdecydować się: perf: subj{np(str)} + {or}
zdecydować się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zdejmować: imperf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zdejmować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdejmować: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zdenerwować: perf: subj{cp(gdy)} + {np(str)}
zdenerwować: perf: subj{cp(jak)} + {np(str)}
zdenerwować: perf: subj{cp(kiedy)} + {np(str)}
zdenerwować: perf: subj{cp(że)} + {np(str)}
zdenerwować: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zdenerwować: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdenerwować się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdenerwować się: perf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
zdenerwować się: perf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zdenerwować się: perf: subj{np(str)} + {prepnp(na,acc)} + {or}
zdenerwować się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
zdenerwować się: perf: subj{np(str)} + {prepnp(o,acc); prepncp(o,acc,int); prepncp(o,acc,że)}
zderzyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zderzyć się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zdjąć: perf: subj{np(str)} + {np(str)} + {prepnp(z,gen)}
zdjąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdjąć: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
zdobić: imperf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zdobić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zdobyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zdobyć się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zdobywać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zdobywać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zdołać: perf: subj,controller{np(str)} + controllee{infp(_)}
zdominować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdradzać: imperf: subj{np(str)} + {np(dat)} + {np(str)} + {or}
zdradzać: imperf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
zdradzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zdradzać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zdradzać się: imperf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zdradzać się: imperf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zdradzać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdradzać się: imperf: subj{np(str)} + {or}
zdradzać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zdradzić: perf: subj{np(str)} + {np(dat)} + {np(str)} + {or}
zdradzić: perf: subj{np(str)} + obj{np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)} + {np(dat)}
zdradzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zdradzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zdradzić się: perf: subj,controller{np(str)} + controllee{prepadjp(jako,str)} + {np(dat)}
zdradzić się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)} + {np(dat)}
zdradzić się: perf: subj{np(str)} + {np(inst)} + {cp(int)}
zdradzić się: perf: subj{np(str)} + {np(inst)} + {cp(że)}
zdradzić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(przed,inst)}
zdradzić się: perf: subj{np(str)} + {or}
zdradzić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zdradzić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen)}
zdradzić się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zdrowieć: imperf: subj{np(str)} + {prepnp(po,loc)}
zdrowieć: imperf: subj{np(str)} + {prepnp(z,gen)}
zdumieć: perf: subj{cp(gdy)} + {np(str)}
zdumieć: perf: subj{cp(int)} + {np(str)}
zdumieć: perf: subj{cp(jak)} + {np(str)}
zdumieć: perf: subj{cp(kiedy)} + {np(str)}
zdumieć: perf: subj{cp(że)} + {np(str)}
zdumieć: perf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zdumieć: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zdumieć się: perf: subj{np(str)} + {cp(int)}
zdumieć się: perf: subj{np(str)} + {cp(że)}
zdumieć się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdumieć się: perf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zdumiewać: imperf: subj{cp(gdy)} + {np(str)}
zdumiewać: imperf: subj{cp(int)} + {np(str)}
zdumiewać: imperf: subj{cp(jak)} + {np(str)}
zdumiewać: imperf: subj{cp(kiedy)} + {np(str)}
zdumiewać: imperf: subj{cp(że)} + {np(str)}
zdumiewać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(str)}
zdumiewać: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {np(str)}
zdumiewać się: imperf: subj{np(str)} + {cp(int)}
zdumiewać się: imperf: subj{np(str)} + {cp(że)}
zdumiewać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdumiewać się: imperf: subj{np(str)} + {prepnp(nad,inst); prepncp(nad,inst,int); prepncp(nad,inst,że)}
zdychać: imperf: subj{np(str)} + {lexnp(inst,sg,'śmierć',atr)}
zdychać: imperf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zdychać: imperf: subj{np(str)} + {np(dat)} + {preplexnp(na,acc,sg,'skutek',natr)}
zdychać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zdychać: imperf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zdychać: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zdychać: imperf: subj{np(str)} + {prepnp(za,acc)}
zdzierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zdzierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zdzierać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zdzierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
zdzierać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
zdzierać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zdziwić: perf: subj{cp(int)} + {np(str)}
zdziwić: perf: subj{cp(że)} + {np(str)}
zdziwić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)}
zdziwić: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zdziwić się: perf: subj{np(str)} + {cp(int)}
zdziwić się: perf: subj{np(str)} + {cp(że)}
zdziwić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)}
zdziwić się: perf: subj{np(str)} + {or}
zebrać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(abl)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zebrać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zebrać się: perf: {np(dat)} + {prepnp(na,acc)}
zebrać się: perf: subj{E} + {prepnp(na,acc)}
zebrać się: perf: subj{np(str)} + {cp(żeby)}
zebrać się: perf: subj{np(str)} + {cp(żeby)} + {preplexnp(w,loc,_,'siebie',natr)}
zebrać się: perf: subj{np(str)} + {prepnp(do,gen)}
zebrać się: perf: subj{np(str)} + {prepnp(w,acc)}
zebrać się: perf: subj{np(str)} + {xp(abl)}
zebrać się: perf: subj{np(str)} + {xp(adl)}
zebrać się: perf: subj{np(str)} + {xp(locat)}
zechcieć: perf: subj,controller{np(str)} + controllee{infp(_)}
zechcieć: perf: subj{np(str)} + {np(str)}
zedrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(do,gen)}
zedrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {prepnp(z,gen)}
zedrzeć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zedrzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)} + {prepnp(z,gen)}
zedrzeć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {prepnp(za,acc)}
zedrzeć się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zejść: perf: {comprepnp(na temat)}
zejść: perf: {np(dat)} + {prepnp(na,loc)}
zejść: perf: {prepnp(na,acc)}
zejść: perf: subj{np(str)} + {comprepnp(na temat)}
zejść: perf: subj{np(str)} + {np(dat)} + {prepnp(na,loc)}
zejść: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen)}
zejść: perf: subj{np(str)} + {np(str)}
zejść: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,gen)}
zejść: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zejść: perf: subj{np(str)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zejść się: perf: subj{np(str)} + {prepnp(do,gen)}
zejść się: perf: subj{np(str)} + {prepnp(z,inst)}
zejść się: perf: subj{np(str)} + {xp(adl)}
zejść się: perf: subj{np(str)} + {xp(locat)}
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)}
zemścić się: perf: subj{ncp(str,że)} + {prepnp(na,loc)}
zemścić się: perf: subj{np(str)} + {np(inst)} + {prepnp(nad,inst)} + {prepnp(za,acc)}
zemścić się: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {prepnp(za,acc); prepncp(za,acc,że)}
zepchnąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zepchnąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zepsuć: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zepsuć się: perf: subj{np(str)} + {np(dat)} + {comprepnp(z powodu)}
zepsuć się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zerkać: imperf: subj{np(str)} + {cp(int)}
zerkać: imperf: subj{np(str)} + {cp(jak)}
zerkać: imperf: subj{np(str)} + {cp(że)}
zerkać: imperf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zerkać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zerkać: imperf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
zerkać: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zerkać: imperf: subj{np(str)} + {prepnp(ku,dat)}
zerkać: imperf: subj{np(str)} + {prepnp(przez,acc); prepncp(przez,acc,int)}
zerkać: imperf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
zerknąć: perf: subj{np(str)} + {cp(int)}
zerknąć: perf: subj{np(str)} + {cp(jak)}
zerknąć: perf: subj{np(str)} + {cp(że)}
zerknąć: perf: subj{np(str)} + {np(dat)} + {prepnp(do,gen)}
zerknąć: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zerknąć: perf: subj{np(str)} + {np(dat)} + {prepnp(przez,acc)}
zerknąć: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zerknąć: perf: subj{np(str)} + {prepnp(ku,dat)}
zerknąć: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int)}
zerknąć: perf: subj{np(str)} + {prepnp(przez,acc)} + {xp(adl)}
zesłać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zesłać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
zesłać: perf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zetknąć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zetknąć się: perf: subj{np(str)} + {prepncp(z,inst,int)}
zetknąć się: perf: subj{np(str)} + {prepncp(z,inst,że)}
zetknąć się: perf: subj{np(str)} + {prepncp(z,inst,żeby2)}
zetknąć się: perf: subj{np(str)} + {prepnp(z,inst)}
zezwalać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zezwalać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zezwalać: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zezwolić: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zezwolić: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zezwolić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zgadzać się: imperf: subj,controller{np(str)} + controllee{infp(_)}
zgadzać się: imperf: subj{cp(że)}
zgadzać się: imperf: subj{np(str)} + {cp(żeby)}
zgadzać się: imperf: subj{np(str); ncp(str,że)}
zgadzać się: imperf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że); prepncp(co do,gen,żeby)} + {prepnp(z,inst)}
zgadzać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zgadzać się: imperf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)} + {prepnp(z,inst)}
zgadzać się: imperf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zgadzać się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
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)}
zgodzić: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zgodzić się: perf: subj,controller{np(str)} + controllee{infp(_)}
zgodzić się: perf: subj{np(str)} + {cp(żeby)}
zgodzić się: perf: subj{np(str)} + {prepnp(co do,gen); prepncp(co do,gen,int); prepncp(co do,gen,że); prepncp(co do,gen,żeby)} + {prepnp(z,inst)}
zgodzić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)}
zgodzić się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zgodzić się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)} + {prepnp(z,inst)}
zgodzić się: perf: subj{np(str)} + {prepnp(z,inst)} + {cp(że)}
zgodzić się: perf: subj{np(str)} + {prepnp(z,inst)} + {or}
zgodzić się: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że); prepncp(z,inst,żeby)}
zgotować: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
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)} + {preplexnp(z,gen,pl,'oko',natr)}
zgubić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zgubić się: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zgubić się: perf: subj{np(str)} + {np(inst)}
zgubić się: perf: subj{np(str)} + {prepnp(w,loc)}
zidentyfikować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(jako,str)}
zidentyfikować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zidentyfikować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zidentyfikować się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zidentyfikować się: perf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,że)}
zielenić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zielenić się: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zielenić się: imperf: subj{np(str)} + {np(inst)}
zielenić się: imperf: subj{np(str)} + {prepnp(od,gen)}
zielenić się: imperf: subj{np(str)} + {prepnp(z,gen)}
ziewać: imperf: subj{np(str)}
zintegrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zintegrować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zintegrować się: perf: subj{np(str)} + {prepnp(wokół,gen)}
zintegrować się: perf: subj{np(str)} + {prepnp(z,inst)}
zipać: imperf: subj{np(str)} + {fixed('ledwie')}
zipać: imperf: subj{np(str)} + {fixed('ledwo')}
zjadać: imperf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zjadać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zjadać: imperf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(str,pl,'ząb',natr)}
zjawiać się: imperf: subj{np(str)} + {prepnp(u,gen)}
zjawiać się: imperf: subj{np(str)} + {xp(locat)}
zjawić się: perf: subj{np(str)} + {prepnp(u,gen)}
zjawić się: perf: subj{np(str)} + {xp(locat)}
zjechać: perf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
zjechać: perf: subj{np(str)} + {prepnp(do,gen)}
zjechać: perf: subj{np(str)} + {prepnp(na,acc)}
zjechać: perf: subj{np(str)} + {xp(abl)}
zjechać: perf: subj{np(str)} + {xp(adl)}
zjechać się: perf: subj{np(str)} + {prepnp(do,gen)}
zjechać się: perf: subj{np(str)} + {prepnp(na,acc)}
zjechać się: perf: subj{np(str)} + {prepnp(z,inst)}
zjechać się: perf: subj{np(str)} + {xp(abl)}
zjechać się: perf: subj{np(str)} + {xp(adl)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zjednoczyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(wokół,gen)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(przeciw,dat)} + {prepnp(z,inst)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zjednoczyć się: perf: subj{np(str)} + {prepnp(wokół,gen)}
zjeść: perf: subj,controller{np(str)} + obj{np(str)} + controllee{xp(mod)}
zjeść: perf: subj{np(str)} + obj{np(part)} + {prepnp(na,acc)}
zjeść: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zjeść: perf: subj{np(str)} + {prepnp(na,loc)} + {lexnp(str,pl,'ząb',natr)}
zjeżdżać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(za,acc); prepncp(za,acc,że)}
zjeżdżać: imperf: subj{np(str)} + {prepnp(do,gen)}
zjeżdżać: imperf: subj{np(str)} + {prepnp(na,acc)}
zjeżdżać: imperf: subj{np(str)} + {xp(abl)}
zjeżdżać: imperf: subj{np(str)} + {xp(adl)}
zjeżdżać się: imperf: subj{np(str)} + {prepnp(do,gen)}
zjeżdżać się: imperf: subj{np(str)} + {prepnp(na,acc)}
zjeżdżać się: imperf: subj{np(str)} + {xp(abl)}
zjeżdżać się: imperf: subj{np(str)} + {xp(adl)}
zlać: perf: subj{np(str)} + {np(inst)} + {np(str); ncp(str,int); ncp(str,że)}
zlać: perf: subj{np(str)} + {np(inst)} + {refl}
zlać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zlać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(po,loc)}
zlać się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zlać się: perf: subj{np(str)} + {np(inst)}
zlecać: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zlecać: imperf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zlecać: imperf: subj{np(str)} + {np(dat)} + {or}
zlecać: imperf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zlecić: perf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
zlecić: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zlecić: perf: subj{np(str)} + {np(dat)} + {cp(żeby)}
zlecić: perf: subj{np(str)} + {np(dat)} + {or}
zlecić: perf: subj{np(str)} + obj{np(str); ncp(str,żeby)} + {np(dat)}
zlewać: imperf: subj{np(str)} + {np(inst)} + {np(str); ncp(str,int); ncp(str,że)}
zlewać: imperf: subj{np(str)} + {np(inst)} + {refl}
zlewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zlewać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zlewać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zlewać: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zlewać: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
zlewać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)} + {prepnp(z,inst)}
zlewać się: imperf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zlewać się: imperf: subj{np(str)} + {np(inst)}
zlewać się: imperf: subj{np(str)} + {prepnp(z,gen)} + {cp(że)}
zlewać się: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
zlikwidować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zlikwidować: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
złamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
złamać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,loc)}
złamać się: perf: subj{np(str)} + {np(dat)} + {prepnp(pod,inst)}
złapać: perf: subj{np(str)} + {cp(int)}
złapać: perf: subj{np(str)} + {cp(że)}
złapać: perf: subj{np(str)} + {np(inst)} + {prepnp(za,acc)} + {refl}
złapać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(za,acc)}
złapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
złapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
złapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
złapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(przy,loc)}
złapać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
złapać: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
złapać: perf: subj{np(str)} + obj{np(str)} + {xp(temp)}
złapać się: perf: subj{np(str)} + {np(gen)}
złapać się: perf: subj{np(str)} + {prepnp(na,acc)}
złapać się: perf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,jak); prepncp(na,loc,że); prepncp(na,loc,żeby2)}
złapać się: perf: subj{np(str)} + {prepnp(w,acc)}
złapać się: perf: subj{np(str)} + {prepnp(za,acc)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
złożyć: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
złożyć się: perf: {np(dat)} + {cp(że)} + {advp(misc)}
złożyć się: perf: {np(dat)} + {prepnp(z,inst)} + {advp(misc)}
złożyć się: perf: subj{np(str)} + {prepnp(do,gen)}
złożyć się: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,że)}
złożyć się: perf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(po,acc)}
zmagać: imperf: subj{np(str)} + obj{np(str)}
zmagać się: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,int); prepncp(z,inst,że)}
zmaleć: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmarnować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
zmarnować: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)} + {lexnp(dat,_,'siebie',natr)}
zmarnować się: perf: subj{np(str)}
zmęczyć: perf: subj{np(str); ncp(str,że)} + {np(str)}
zmęczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zmęczyć się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zmieniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{prepadjp(na,acc)}
zmieniać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{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)} + controllee{prepadjp(na,acc)} + {prepadjp(z,gen)}
zmieniać się: imperf: subj,controller{np(str)} + controllee{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)} + controllee{prepadjp(na,acc)}
zmienić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{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)} + controllee{prepadjp(na,acc)} + {prepadjp(z,gen)}
zmienić się: perf: subj,controller{np(str)} + controllee{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)}
zmieszać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zmieszać się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zmieszać się: perf: subj{np(str)} + {np(inst)}
zmieścić: perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
zmieścić: perf: subj{np(str)} + {np(str)} + {xp(locat)}
zmieścić się: perf: subj{np(str)} + {prepnp(w,loc)}
zmieścić się: perf: subj{np(str)} + {xp(locat)}
zmniejszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zmniejszać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmniejszyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zmniejszyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zmobilizować: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zmobilizować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {cp(żeby)}
zmobilizować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(przeciw,dat)}
zmobilizować się: perf: subj{np(str)} + {np(inst)} + {cp(żeby)}
zmobilizować się: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zmobilizować się: perf: subj{np(str)} + {prepnp(przeciw,dat)}
zmodernizować: perf: subj{np(str)} + {np(inst)} + {refl}
zmodernizować: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zmodyfikować: perf: subj{np(str)} + obj{np(str); ncp(str,int)} + {np(dat)} + {np(inst)}
zmodyfikować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(u,gen)}
zmodyfikować: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(w,loc)}
zmodyfikować się: perf: subj{np(str)}
zmoknąć: perf: subj,controller{np(str)} + controllee{xp(mod)} + {xp(locat)}
zmoknąć: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
znaczyć: imperf: subj{infp(_)} + {infp(_)}
znaczyć: imperf: subj{infp(_)} + {np(str)}
znaczyć: imperf: subj{np(str)} + {cp(że)}
znaczyć: imperf: subj{np(str)} + {np(str)} + {prepnp(dla,gen)}
znaczyć: imperf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
znaczyć: imperf: subj{np(str)} + {np(str)} + {xp(locat)}
znaczyć: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
znaczyć: imperf: subj{np(str)} + {or}
znaczyć się: perf: subj{np(str)} + {np(inst)} + {xp(locat)}
znać: imperf: {np(str)} + {prepnp(po,loc)}
znać: imperf: {prepnp(po,loc)} + {cp(że)}
znać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
znać: imperf: subj{np(str)} + obj{cp(int)}
znać: imperf: subj{np(str)} + obj{np(str)}
znać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(od,gen,sg,'podszewka',natr)}
znać się: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,int)}
znać się: imperf: subj{np(str)} + {prepnp(z,inst)}
znajdować: imperf: subj{np(str)} + {cp(że)}
znajdować: imperf: subj{np(str)} + {np(str)} + {advp(pron)}
znajdować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(inst)}
znajdować: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(str)}
znajdować: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
znajdować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
znajdować: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znajdować się: imperf: subj,controller{np(str)} + controllee{adjp(inst)}
znajdować się: imperf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
znajdować 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)} + controllee{adjp(inst)}
znaleźć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{adjp(str)}
znaleźć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
znaleźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(u,gen); xp(locat)}
znaleźć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
znaleźć się: perf: subj,controller{np(str)} + controllee{adjp(inst)}
znaleźć się: perf: subj{np(str)} + {prepnp(bez,gen)}
znaleźć się: perf: subj{np(str)} + {prepnp(u,gen); xp(locat)}
znaleźć się: perf: subj{np(str)} + {prepnp(w,loc)}
znęcać się: imperf: subj{np(str)} + {prepnp(nad,inst)}
zniechęcać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcać się: imperf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
zniechęcić się: perf: subj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(do,gen); prepncp(do,gen,żeby)}
znieść: perf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(jak)}
znieść: perf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(że)}
znieść: perf: subj,controller{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + controllee{xp(mod)}
znieść: perf: subj{np(str)} + {cp(gdy)}
znieść: perf: subj{np(str)} + {cp(jak)}
znieść: perf: subj{np(str)} + {cp(kiedy)}
znieść: perf: subj{np(str)} + {cp(że)}
znieść: perf: subj{np(str)} + {np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)}
znieść: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
znieść: perf: subj{np(str)} + obj{np(str)} + {xp(abl)}
znieść: perf: subj{np(str)} + obj{np(str)} + {xp(adl)}
znikać: imperf: subj{np(str)} + {np(dat)} + {xp(abl)}
znikać: imperf: subj{np(str)} + {np(dat)} + {xp(locat)}
zniknąć: perf: subj{np(str)} + {np(dat)} + {xp(abl)}
zniknąć: perf: subj{np(str)} + {np(dat)} + {xp(locat)}
zniszczyć: perf: subj{np(str)} + {np(inst)} + {refl}
zniszczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
zniszczyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(od,gen)}
zniweczyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst); ncp(inst,że)}
znosić: imperf: subj,controller{np(str)} + controllee{infp(imperf)}
znosić: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(jak)}
znosić: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {cp(że)}
znosić: imperf: subj,controller{np(str)} + obj{np(str); ncp(str,gdy); ncp(str,int); ncp(str,jak); ncp(str,kiedy); ncp(str,że)} + controllee{xp(mod)}
znosić: imperf: subj{np(str)} + {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)}
znowelizować: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
znudzić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
znudzić się: perf: subj,controllee{infp(imperf)} + controller{np(dat)}
znudzić się: perf: subj{cp(że)} + {np(dat)}
znudzić się: perf: subj{np(str); ncp(str,że)} + {np(dat)}
znudzić się: perf: subj{np(str)} + {np(inst); ncp(inst,że)}
zobaczyć: perf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)}
zobaczyć: perf: subj{np(str)} + {cp(jak)} + {preplexnp(na,acc,pl,'oko',batr)}
zobaczyć: perf: subj{np(str)} + {cp(żeby2)}
zobaczyć: perf: subj{np(str)} + {cp(że)} + {preplexnp(na,acc,pl,'oko',batr)}
zobaczyć: perf: subj{np(str)} + {lexnp(inst,_,'oko',ratr)} + {refl}
zobaczyć: perf: subj{np(str)} + {np(str); cp(int); cp(jak); cp(że); ncp(str,int); ncp(str,jak); ncp(str,że)}
zobaczyć: perf: subj{np(str)} + {np(str); ncp(str,że)} + {preplexnp(na,acc,pl,'oko',batr)}
zobaczyć: perf: subj{np(str)} + {np(str)} + {prepnp(w,loc)}
zobaczyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zobaczyć się: perf: subj,controller{np(str)} + controllee{adjp(inst)}
zobaczyć się: perf: subj{np(str)} + {prepnp(z,inst)}
zobowiązać: perf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zobowiązać: perf: subj,controller{np(str)} + obj{np(str)} + controllee{infp(_)}
zobowiązać: perf: subj{np(str)} + {np(inst)} + {cp(żeby)} + {refl}
zobowiązać: perf: subj{np(str)} + {np(inst)} + {cp(że)} + {refl}
zobowiązać: perf: subj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {refl}
zobowiązać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)}
zobowiązać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)}
zobowiązać: perf: subj{np(str)} + {prepnp(do,gen); prepncp(do,gen,że); prepncp(do,gen,żeby)} + {prepnp(w,loc)} + {refl}
zobowiązać: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(żeby)} + {refl}
zobowiązać: perf: subj{np(str)} + {prepnp(w,loc)} + {cp(że)} + {refl}
zobowiązywać: imperf: subj,controller{np(str)} + controllee{infp(_)} + {refl}
zobowiązywać: imperf: subj,controller{np(str)} + obj{np(str)} + controllee{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}
zorientować: perf: subj{np(str)} + obj{np(str)} + {cp(int)}
zorientować: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zorientować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
zorientować się: perf: subj{np(str)} + {cp(int)}
zorientować się: perf: subj{np(str)} + {cp(że)}
zorientować się: perf: subj{np(str)} + {or}
zorientować się: perf: subj{np(str)} + {prepnp(na,acc)}
zorientować się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,int); prepncp(w,loc,że)}
zostać: perf: subj,controllee{infp(_)} + controller{np(dat)}
zostać: perf: subj,controller{np(str)} + controllee{adjp(pred)}
zostać: perf: subj,controller{np(str)} + controllee{np(inst)}
zostać: perf: subj{ncp(str,że)} + {np(dat)}
zostać: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostać: perf: subj{np(str)} + {np(dat)} + {prepnp(po,loc)}
zostać: perf: subj{np(str)} + {np(dat)} + {prepnp(w,loc)} + {prepnp(z,gen)}
zostać: perf: subj{np(str)} + {prepnp(bez,gen)}
zostać: perf: subj{np(str)} + {prepnp(między,inst)}
zostać: perf: subj{np(str)} + {prepnp(na,loc)}
zostać: perf: subj{np(str)} + {prepnp(przy,loc)}
zostać: perf: subj{np(str)} + {prepnp(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)}
zostawiać: imperf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)} + {xp(locat)}
zostawiać: imperf: subj{np(str)} + {np(inst)} + {np(str)}
zostawiać: imperf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',natr)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zostawiać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
zostawić: perf: subj{np(str)} + controller{np(str)} + controllee{adjp(pred)} + {xp(locat)}
zostawić: perf: subj{np(str)} + {np(inst)} + {np(str)}
zostawić: perf: subj{np(str)} + {np(str)} + {preplexnp(za,inst,_,'siebie',natr)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(na,acc)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(locat)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(bez,gen,sg,'komentarz',natr)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(na,loc,sg,'lód',natr)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(przy,loc,sg,'życie',natr)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {preplexnp(w,loc,sg,'spokój',natr)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)} + {xp(locat)}
zostawić: perf: subj{np(str)} + obj{np(str)} + {prepnp(po,loc)} + {prepnp(w,loc)}
zranić: perf: subj{cp(gdy)} + {np(str)}
zranić: perf: subj{cp(jak)} + {np(str)}
zranić: perf: subj{cp(jeśli)} + {np(str)}
zranić: perf: subj{cp(kiedy)} + {np(str)}
zranić: perf: subj{cp(że)} + {np(str)}
zranić: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)} + {prepnp(w,acc)}
zranić: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)} + {refl}
zranić się: perf: subj{np(str)} + {np(inst)} + {prepnp(w,acc)}
zranić się: perf: subj{np(str)} + {prepnp(o,acc)} + {prepnp(w,acc)}
zrazić: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrazić: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)}
zrazić się: perf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrażać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrażać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {lexnp(dat,_,'siebie',natr)}
zrażać się: imperf: subj{np(str)} + {np(inst); ncp(inst,int); ncp(inst,że)} + {prepnp(do,gen)}
zrealizować: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zrealizować się: perf: subj,controller{np(str)} + controllee{prepnp(jako,str)}
zrealizować się: perf: subj{np(str)} + {prepnp(w,loc); prepncp(w,loc,że)}
zremisować: perf: subj{np(str)} + obj{np(str)}
zremisować: perf: subj{np(str)} + {prepnp(z,inst)}
zrezygnować: perf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że); prepncp(z,gen,żeby)}
zrobić: perf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
zrobić: perf: subj{np(str)} + {cp(że)} + {advp(misc)}
zrobić: perf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {advp(misc)}
zrobić: perf: subj{np(str)} + {np(inst)} + {prepnp(na,loc)} + {lexnp(str,sg,'wrażenie',atr)}
zrobić: perf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
zrobić: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zrobić: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,loc)}
zrobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(dla,gen)}
zrobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zrobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrobić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zrobić: perf: subj{np(str)} + {prepnp(w,acc)}
zrobić: perf: subj{np(str)} + {prepnp(z,gen)} + {nonch} + {lexnp(dat,_,'siebie',natr)}
zrobić się: perf: {np(dat)} + {xp(mod)}
zrobić się: perf: subj,controller{np(str)} + controllee{adjp(pred)}
zrobić się: perf: subj,controller{np(str)} + controllee{np(inst)}
zrobić się: perf: subj,controller{np(str)} + controllee{prepnp(na,acc)}
zrobić się: perf: subj{np(str)} + {prepnp(z,gen)}
zrozumieć: perf: subj{np(str)} + {np(str); cp(int); cp(że); ncp(str,int); ncp(str,że)}
zrozumieć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zrozumieć: perf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zrzec się: perf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {comprepnp(na rzecz)}
zrzec się: perf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
zrzekać się: imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {comprepnp(na rzecz)}
zrzekać się: imperf: subj{np(str)} + {np(gen); ncp(gen,żeby)} + {preplexnp(na,acc,sg,'korzyść',ratr)}
zrzeszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
zrzeszać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zrzeszać się: imperf: subj{np(str)} + {prepnp(w,acc)}
zrzeszać się: imperf: subj{np(str)} + {prepnp(w,loc)}
zrzucać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zrzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zrzucać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrzucać: imperf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zrzucać się: imperf: subj{np(str)} + {prepnp(na,acc)}
zrzucić: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)} + {xp(adl)}
zrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zrzucić: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zrzucić: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zrzucić się: perf: subj{np(str)} + {prepnp(na,acc)}
zsunąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zsunąć się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsuwać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)}
zsuwać się: perf: subj{np(str)} + {np(dat)} + {xp(abl)} + {xp(adl)} + {xp(perl)}
zsyłać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {xp(abl)}
zsyłać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)} + {xp(abl)}
zsyłać: imperf: subj{np(str)} + obj{np(str)} + {xp(abl)} + {xp(adl)}
zużyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zużyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zużyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zużyć się: perf: subj{np(str)} + {prepnp(na,loc)}
zużyć się: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zużywać: perf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
zużywać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc); prepncp(na,acc,żeby)}
zużywać: perf: subj{np(str)} + obj{np(str)} + {prepnp(na,loc)}
zużywać się: perf: subj{np(str)} + {prepnp(na,loc)}
zużywać się: perf: subj{np(str)} + {prepnp(od,gen); prepncp(od,gen,że)}
zwać: imperf: subj,controller{np(str)} + controllee{np(inst)} + {refl}
zwać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(inst)}
zwać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{np(nom)}
zwać: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
zwać się: imperf: subj,controller{np(str)} + controllee{np(inst)}
zwać się: imperf: subj,controller{np(str)} + controllee{np(nom)}
zwać się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
zwalczać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(inst)}
zwariować: perf: subj{np(str)} + {preplexnp(na,loc,sg,'punkt',ratr)}
zwariować: perf: subj{np(str)} + {prepnp(dla,gen)}
zwariować: perf: subj{np(str)} + {prepnp(od,gen)}
zwariować: perf: subj{np(str)} + {prepnp(z,gen)}
zważać: imperf: subj{np(str)} + {cp(int)}
zważać: imperf: subj{np(str)} + {cp(że)}
zważać: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zważyć: perf: subj{np(str)} + {cp(int)}
zważyć: perf: subj{np(str)} + {cp(że)}
zważyć: perf: subj{np(str)} + obj{np(str)}
zważyć: perf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
zważyć: perf: subj{np(str)} + {refl}
zweryfikować: perf: subj{np(str); ncp(str,int); ncp(str,że)} + obj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zweryfikować: perf: subj{np(str)} + obj,controller{np(str)} + controllee{prepnp(jako,str)}
zweryfikować: perf: subj{np(str)} + obj{cp(int)}
zweryfikować: perf: subj{np(str)} + obj{cp(że)}
zweryfikować: perf: subj{np(str)} + obj{np(str)} + {xp(locat)}
zwiastować: _: subj{np(str)} + {np(dat)} + {cp(że)}
zwiastować: _: subj{np(str)} + {np(dat)} + {cp(żeby2)}
zwiastować: _: subj{np(str)} + obj{np(str); ncp(str,że)} + {np(dat)}
związać: perf: subj,controller{np(str)} + controllee{xp(mod)} + {lexnp(str,sg,'koniec',natr)} + {preplexnp(z,inst,sg,'koniec',natr)}
związać: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)} + {refl}
związać: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {np(inst)}
związać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,acc)}
związać: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
związać się: perf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
zwiedzać: imperf: subj{np(str)} + obj{np(str)}
zwiedzić: perf: subj{np(str)} + obj{np(str)}
zwierzać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwierzać się: imperf: subj{np(str)} + {np(dat)} + {cp(że)}
zwierzać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zwierzać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zwierzać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzać się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
zwierzyć: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwierzyć się: perf: subj{np(str)} + {np(dat)} + {cp(że)}
zwierzyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(z,inst)}
zwierzyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {cp(że)}
zwierzyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,gen); prepncp(z,gen,int); prepncp(z,gen,że)}
zwierzyć się: perf: subj{np(str)} + {prepnp(przed,inst)} + {prepnp(z,inst)}
zwieść: perf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zwieść: perf: subj{np(str)} + obj{np(str)} + {cp(że)}
zwieść: perf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
zwiększać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwiększać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwiększyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(o,acc)}
zwiększyć się: perf: subj{np(str)} + {np(dat)} + {prepnp(o,acc)}
zwijać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwijać się: imperf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwijać się: imperf: subj{np(str)} + {prepnp(z,gen)}
zwijać się: imperf: subj{np(str)} + {prepnp(z,inst)}
zwijać się: imperf: subj{np(str)} + {xp(abl)}
zwijać się: imperf: subj{np(str)} + {xp(adl)}
zwinąć: perf: subj{np(str)} + obj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwinąć się: perf: subj{np(str)} + {np(dat)} + {prepnp(w,acc)}
zwinąć się: perf: subj{np(str)} + {prepnp(z,gen)}
zwinąć się: perf: subj{np(str)} + {prepnp(z,inst)}
zwinąć się: perf: subj{np(str)} + {xp(abl)}
zwinąć się: perf: subj{np(str)} + {xp(adl)}
zwisać: imperf: subj{cp(int)} + {np(dat)} + {np(inst)}
zwisać: imperf: subj{cp(że)} + {np(dat)} + {np(inst)}
zwisać: imperf: subj{np(str); ncp(str,int); ncp(str,że)} + {np(dat)} + {np(inst)}
zwisać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(abl)}
zwisać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(adl)}
zwisać: imperf: subj{np(str)} + {np(dat)} + {np(inst)} + {xp(locat)}
zwlekać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)}
zwlekać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwlekać: imperf: subj{np(str)} + {prepnp(z,inst); prepncp(z,inst,żeby)} + {xp(dur)}
zwlekać się: imperf: subj{np(str)} + {prepnp(z,gen)}
zwlekać się: imperf: subj{np(str)} + {xp(abl)}
zwodzić: imperf: subj{np(str)} + {cp(że)} + {refl}
zwodzić: imperf: subj{np(str); ncp(str,że)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zwodzić: imperf: subj{np(str)} + {np(inst)} + {refl}
zwodzić: imperf: subj{np(str)} + obj{np(str)} + {cp(że)}
zwodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,gen)} + {xp(adl)}
zwodzić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
zwołać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zwołać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zwołać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zwołać: perf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zwoływać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(do,gen)}
zwoływać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {prepnp(na,acc)}
zwoływać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(adl)}
zwoływać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)} + {xp(locat)}
zwracać: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'uwaga',atr)}
zwracać: imperf: subj{np(str)} + {np(dat)} + {prepnp(za,acc)}
zwracać: imperf: subj{np(str)} + obj{lexnp(str,sg,'uwaga',atr)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zwracać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zwracać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zwracać: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwracać się: imperf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
zwracać się: imperf: subj{np(str)} + {np(dat)}
zwracać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
zwracać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zwracać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zwracać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
zwracać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepncp(z,inst,żeby)}
zwracać się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zwracać się: imperf: subj{np(str)} + {prepnp(ku,dat)}
zwracać się: imperf: subj{np(str)} + {prepnp(przeciw,dat)}
zwrócić: imperf: subj{np(str)} + {np(dat)} + {cp(że)} + {lexnp(str,sg,'uwaga',atr)}
zwrócić: imperf: subj{np(str)} + obj{lexnp(str,sg,'uwaga',atr)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że); prepncp(na,acc,żeby)}
zwrócić: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zwrócić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(na,acc)}
zwrócić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(przeciw,dat)}
zwrócić: imperf: subj{np(str)} + obj{np(str)} + {xp(adl)}
zwrócić się: perf: subj{np(str)} + controller{prepnp(do,gen)} + controllee{xp(mod)}
zwrócić się: perf: subj{np(str)} + {np(dat)}
zwrócić się: perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w kwestii)}
zwrócić się: perf: subj{np(str)} + {prepnp(do,gen)} + {comprepnp(w sprawie)}
zwrócić się: perf: subj{np(str)} + {prepnp(do,gen)} + {cp(żeby)}
zwrócić się: perf: subj{np(str)} + {prepnp(do,gen)} + {or}
zwrócić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepncp(z,inst,żeby)}
zwrócić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
zwrócić się: perf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(z,inst)}
zwrócić się: perf: subj{np(str)} + {prepnp(ku,dat)}
zwrócić się: perf: subj{np(str)} + {prepnp(przeciw,dat)}
zwyciężać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwyciężać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zwyciężać: imperf: subj{np(str)} + {prepnp(nad,inst)}
zwyciężać: imperf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zwyciężyć: perf: subj{np(str)} + obj{np(str)} + {np(inst)}
zwyciężyć: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zwyciężyć: perf: subj{np(str)} + {prepnp(nad,inst)}
zwyciężyć: perf: subj{np(str)} + {prepnp(w,loc)} + {prepnp(z,inst)}
zwyknąć: perf: subj,controller{np(str)} + controllee{infp(_)}
zwyknąć: perf: subj{np(str)} + {cp(żeby)}
zyskać: perf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zyskać: perf: subj{np(str)} + obj{np(str)} + {np(dat)}
zyskać: perf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zyskać: perf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zyskiwać: imperf: subj{np(str)} + obj{np(str); ncp(str,że)} + {prepnp(na,loc); prepncp(na,loc,że)}
zyskiwać: imperf: subj{np(str)} + obj{np(str)} + {np(dat)}
zyskiwać: imperf: subj{np(str)} + obj{np(str)} + {np(inst); ncp(inst,że)}
zyskiwać: imperf: subj{np(str)} + obj{np(str)} + {prepnp(w,loc)}
zżymać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,gen)}
zżymać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {comprepnp(z powodu)}
zżymać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(int)}
zżymać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {cp(że)}
zżymać się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {or}
zżymać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(o,acc); prepncp(o,acc,że)}
zżymać się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(za,acc); prepncp(za,acc,że)}
żal: imperf: controller{np(dat)} + controllee{infp(_)}
żal: imperf: {np(dat)} + {cp(że)}
żal: imperf: {np(dat)} + {np(gen); ncp(gen,że)}
żal: imperf: {np(dat)} + {prepnp(za,acc)}
żal: imperf: {np(dat)} + {prepnp(za,inst)}
żalić się: imperf: subj{np(str)} + {np(dat)} + {cp(int)}
żalić się: imperf: subj{np(str)} + {np(dat)} + {or}
żalić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc)} + {cp(że)}
żalić się: imperf: subj{np(str)} + {np(dat)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
żalić się: imperf: subj{np(str)} + {prepnp(do,gen)} + {or}
żalić się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc)} + {cp(że)}
żalić się: imperf: subj{np(str)} + {prepnp(do,gen)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)}
żalić się: imperf: subj{np(str)} + {prepnp(na,acc); prepncp(na,acc,int); prepncp(na,acc,że)} + {prepnp(przed,inst)}
żalić się: imperf: subj{np(str)} + {prepnp(na,acc)} + {prepnp(przed,inst)} + {cp(że)}
żalić się: imperf: subj{np(str)} + {prepnp(przed,inst)} + {or}
żałować: imperf: subj{np(str)} + {np(dat)} + {np(gen)} + {prepnp(na,acc)}
żałować: imperf: subj{np(str)} + {np(gen); cp(że); ncp(gen,że)}
żałować: imperf: subj{np(str)} + {np(gen)} + {or}
żałować: imperf: subj{np(str)} + {prepnp(za,acc)}
żartować: 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}
żebrać: imperf: subj{np(str)} + {np(gen)} + {np(inst)}
żebrać: imperf: subj{np(str)} + {np(inst)} + {cp(żeby)}
żebrać: imperf: subj{np(str)} + {np(inst)} + {prepnp(o,acc); prepncp(o,acc,żeby)}
żegnać: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
żegnać się: imperf: subj{np(str)} + {np(inst)} + {prepnp(z,inst)}
żenić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(z,inst)}
żenić się: imperf: subj{np(str)} + {prepnp(dla,gen)} + {prepnp(z,inst)}
żenić się: imperf: subj{np(str)} + {prepnp(z,gen)} + {prepnp(z,inst)}
żerować: imperf: subj{np(str)} + {prepnp(na,loc); prepncp(na,loc,że)}
żerować: imperf: subj{np(str)} + {xp(locat)}
żółcić: imperf: subj{np(str)} + obj{np(str)}
żółcić się: imperf: subj{np(str)} + {np(inst)}
żółcić się: imperf: subj{np(str)} + {xp(locat)}
życzyć: imperf: subj{np(str)} + controller{np(dat)} + controllee{infp(_)}
życzyć: imperf: subj{np(str)} + {np(dat)} + {np(gen); cp(żeby); ncp(gen,żeby); advp(misc)}
życzyć: imperf: subj{np(str)} + {np(dat)} + {or}
życzyć: imperf: subj{np(str)} + {np(gen)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
życzyć: imperf: subj{np(str)} + {np(str)} + {prepnp(za,acc)} + {lexnp(dat,_,'siebie',natr)}
żyć: imperf: subj,controller{np(str)} + controllee{xp(mod)} + {prepnp(z,inst)}
żyć: imperf: subj{np(str)} + {np(inst)}
żyć: imperf: subj{np(str)} + {preplexnp(na,loc,pl,'walizka',natr)}
żyć: imperf: subj{np(str)} + {prepnp(dla,gen)}
żyć: imperf: subj{np(str)} + {prepnp(na,acc)}
żyć: imperf: subj{np(str)} + {prepnp(z,gen); prepncp(z,gen,że)}
żyć: imperf: subj{np(str)} + {xp(dur)}
żyć: imperf: subj{np(str)} + {xp(locat)}
żyć: imperf: subj{np(str)} + {xp(temp)}
żywić: imperf: subj{np(str)} + obj,controller{np(str)} + controllee{xp(mod)}
żywić: imperf: subj{np(str)} + obj{np(str)} + {np(inst)}
żywić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(do,gen)}
żywić: imperf: subj{np(str)} + obj{np(str)} + {prepnp(wobec,gen)}
żywić się: imperf: subj,controller{np(str)} + controllee{xp(mod)}
żywić się: imperf: subj{np(str)} + {np(inst)}
