% Walenty: a valence dictionary of Polish
% http://zil.ipipan.waw.pl/Walenty
% version: July 26, 2018
%
% © Copyright 2012–2018 by the Institute of Computer Science, Polish
% Academy of Sciences (IPI PAN)
%
% This work is distributed under a CC BY-SA license:
% http://creativecommons.org/licenses/by-sa/4.0/
%
% Walenty is a valence dictionary of Polish developed at the Institute
% of Computer Science, Polish Academy of Sciences (IPI PAN). It currently
% contains 101045 schemata and 28409 frames for 18236 lemmata.
%
% The original formalism of Walenty was established by Filip Skwarski,
% Elżbieta Hajnicz, Agnieszka Patejuk, Adam Przepiórkowski, Marcin
% Woliński, Marek Świdziński, and Magdalena Zawisławska. It has been
% further developed by Elżbieta Hajnicz, Agnieszka Patejuk, Adam
% Przepiórkowski, and Marcin Woliński. The semantic layer has been
% developed by Elżbieta Hajnicz and Anna Andrzejczuk.
%
% The original seed of Walenty was provided by the automatic
% conversion, manually reviewed by Filip Skwarski, of the verbal valence
% dictionary used by the Świgra2 parser (6396 schemata for 1462 lemmata),
% which was in turn based on SDPV, the Syntactic Dictionary of Polish
% Verbs by Marek Świdziński (4148 schemata for 1064 lemmata). Afterwards,
% Walenty has been developed independently by adding new entries, 
% syntactic schemata, in particular phraseological ones, and semantic
% frames.
%
% Walenty has been edited and compiled using the Slowal tool
% (http://zil.ipipan.waw.pl/Slowal) created by Bartłomiej Nitoń and
% Tomasz Bartosiak.
%
% Parameters:
%     Schema opinions: pewny, wątpliwy, zły, archaiczny, potoczny, wulgarny
%     Lemma statuses: gotowe, zalążkowe, sprawdzone, (F) w obróbce, (F) gotowe, (F) sprawdzone, (S) w obróbce, (S) gotowe, (S) sprawdzone
%     Part of speech: adv
%     Opinions added: True
%
absurdalnie: pewny: : : : {cp(że)}
absurdalnie: pewny: : : : {infp(_)}
bajecznie: wątpliwy: : : : {cp(że)}
bajecznie: pewny: : : : {prepnp(dla,gen)}
banalnie: pewny: : pred: : {infp(_)}
bezpiecznie: pewny: : : : {comprepnp(pod względem)}
bezpiecznie: pewny: : : : {infp(_)}
bezpiecznie: pewny: : : : {np(dat)} + {xp(locat)}
bezpiecznie: pewny: : : : {prepnp(dla,gen);comprepnp(w stosunku do)}
bezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
bezpiecznie: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
bezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
bezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
bezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
bezpiecznie: pewny: : : : {xp(mod[advp(mod)])}
bezsensownie: pewny: : : : {infp(_)}
blisko: pewny: : : : {np(dat)} + {prepnp(do,gen)} + {comprepnp(pod względem)}
blisko: pewny: : : : {prepnp(do,gen)} + {prepnp(od,gen)}
blisko: pewny: : : : {xp(abl)} + {xp(adl)}
bliziutko: pewny: : : : {np(dat)} + {prepnp(do,gen)} + {comprepnp(pod względem)}
bliziutko: pewny: : : : {prepnp(do,gen)} + {prepnp(od,gen)}
bliziutko: pewny: : : : {xp(abl)} + {xp(adl)}
błędnie: pewny: : : : {comprepnp(pod względem)}
błędnie: pewny: : : : {infp(_)}
błędnie: wątpliwy: : : : {prepnp(co do,gen)}
błędnie: wątpliwy: : : : {prepnp(wobec,gen)}
błędnie: pewny: : : : {xp(mod[advp(mod)])}
błogo: pewny: : : : controller{np(dat)} + controllee{infp(_)}
błogo: pewny: : : : {np(dat)} + {cp(gdy)}
błogo: potoczny: : : : {np(dat)} + {cp(jak)}
błogo: pewny: : : : {np(dat)} + {cp(kiedy)}
błogo: pewny: : : : {np(dat)} + {prepnp(na,loc)}
błogo: pewny: : : : {np(dat)} + {prepnp(z,inst)}
boleśnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
boleśnie: pewny: : : : {prepnp(dla,gen)}
bosko: pewny: : : : {cp(gdy)}
bosko: potoczny: : : : {cp(jak)}
bosko: pewny: : : : {cp(jeśli)}
bosko: pewny: : : : {cp(kiedy)}
bosko: pewny: : : : {cp(że)}
bosko: pewny: : : : {infp(_)}
bosko: pewny: : : : {np(dat)} + {prepnp(w,loc)}
bosko: pewny: : : : {np(dat)} + {prepnp(z,inst)}
bosko: pewny: : : : {np(dat)} + {xp(locat)}
brzydko: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
brzydko: pewny: : : : {cp(gdy)}
brzydko: potoczny: : : : {cp(int)}
brzydko: pewny: : : : {cp(jeśli)}
brzydko: pewny: : : : {cp(kiedy)}
brzydko: pewny: : : : {infp(_)}
brzydko: pewny: : : : {np(dat)} + {prepnp(w,loc)}
brzydko: wątpliwy: : : : {prepnp(dla,gen)} + {cp(żeby)}
brzydko: pewny: : : : {xp(locat)}
chłodno: pewny: : : : {np(dat)} + {prepnp(w,acc)}
chłodno: pewny: : : : {np(dat)} + {prepnp(w,loc)}
chłodno: pewny: : : : {np(dat)} + {xp(caus)}
chłodno: pewny: : : : {np(dat)} + {xp(locat)}
chwalebnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
chwalebnie: pewny: : : : {infp(_)}
ciasno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
ciasno: pewny: : : : {np(dat)} + {comprepnp(z powodu)}
ciasno: pewny: : : : {np(dat)} + {prepnp(z,inst)} + {xp(locat)}
ciasno: pewny: : : : {prepnp(dla,gen)} + {xp(locat)}
ciekawie: pewny: : : : {comprepnp(pod względem)}
ciekawie: pewny: : : : {infp(_)}
ciekawie: pewny: : : : {prepnp(dla,gen)} + {xp(locat)}
ciekawie: pewny: : : : {xp(mod[advp(mod)])}
ciemnawo: pewny: : : : {xp(locat)}
ciemno: pewny: : : : {np(dat)}
ciemno: pewny: : : : {xp(locat)}
cienko: pewny: : : : {comprepnp(pod względem)} + {xp(locat)}
cienko: pewny: : : : {prepnp(z,inst)} + {xp(locat)}
cienko: pewny: : : : {xp(locat)} + {xp(mod[advp(mod)])}
cieplutko: pewny: : : : {np(dat)} + {prepnp(na,loc)}
cieplutko: pewny: : : : {np(dat)} + {prepnp(od,gen)} + {prepnp(w,acc)}
cieplutko: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {prepnp(w,loc)}
cieplutko: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {xp(locat)}
ciepło: pewny: : : : {np(dat)} + {prepnp(na,loc)}
ciepło: pewny: : : : {np(dat)} + {prepnp(od,gen)} + {prepnp(w,acc)}
ciepło: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {prepnp(w,loc)}
ciepło: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {xp(locat)}
ciężko: pewny: : : : controller{np(dat)} + controllee{infp(_)}
ciężko: pewny: : : : {np(dat)} + {comprepnp(pod względem)}
ciężko: pewny: : : : {np(dat)} + {comprepnp(ze względu na)}
ciężko: pewny: : : : {np(dat)} + {cp(gdy)}
ciężko: potoczny: : : : {np(dat)} + {cp(jak)}
ciężko: pewny: : : : {np(dat)} + {cp(kiedy)}
ciężko: pewny: : : : {np(dat)} + {prepnp(bez,gen)}
ciężko: pewny: : : : {np(dat)} + {prepnp(na,loc)} + {cp(że)}
ciężko: pewny: : : : {np(dat)} + {prepnp(w,loc)}
ciężko: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,że)}
ciężko: pewny: : : : {np(dat)} + {xp(caus)}
ciężko: pewny: : : : {np(dat)} + {xp(locat)}
ciężko: pewny: : : : {np(dat)} + {xp(temp)}
ciężko: pewny: : : : {prepnp(z,inst)} + {xp(locat)}
cudnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
cudnie: pewny: : : : {cp(gdy)}
cudnie: potoczny: : : : {cp(jak)}
cudnie: pewny: : : : {cp(jeśli)}
cudnie: pewny: : : : {cp(kiedy)}
cudnie: pewny: : : : {cp(że)}
cudnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
cudnie: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,że)}
cudnie: pewny: : : : {xp(locat)}
cudownie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
cudownie: pewny: : : : {cp(gdy)}
cudownie: potoczny: : : : {cp(jak)}
cudownie: pewny: : : : {cp(jeśli)}
cudownie: pewny: : : : {cp(kiedy)}
cudownie: pewny: : : : {np(dat)} + {cp(że)}
cudownie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
cudownie: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,że)}
cudownie: pewny: : : : {np(dat)} + {xp(locat)}
czczo: archaiczny: : : : {np(dat)}
daleko: pewny: : : : {np(dat)} + {prepnp(do,gen)} + {comprepnp(pod względem)}
daleko: pewny: : : : {prepnp(do,gen)} + {prepnp(od,gen)}
daleko: pewny: : : : {xp(abl)} + {xp(adl)}
dobrze: pewny: : : : controller{np(dat)} + controllee{infp(_)}
dobrze: pewny: : : : {np(dat)} + {cp(gdy)}
dobrze: potoczny: : : : {np(dat)} + {cp(jak)}
dobrze: pewny: : : : {np(dat)} + {cp(jeśli)}
dobrze: pewny: : : : {np(dat)} + {cp(kiedy)}
dobrze: pewny: : : : {np(dat)} + {cp(że)}
dobrze: pewny: : : : {np(dat)} + {prepnp(w,loc)}
dobrze: pewny: : : : {np(dat)} + {prepnp(z,inst)}
dobrze: pewny: : : : {np(dat)} + {xp(locat)}
dobrze: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
dobrze: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
dobrze: pewny: : : : {prepnp(dla,gen)} + {cp(jakby)}
dobrze: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
dobrze: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
dobrze: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
dobrze: pewny: : : : {prepnp(dla,gen)} + {cp(żeby)}
doskonale: wątpliwy: : : : {cp(jeśli)}
doskonale: pewny: : : : {cp(że)}
doskonale: pewny: : : : {infp(_)}
duszno: pewny: : : : {np(dat)} + {prepnp(w,loc)}
duszno: pewny: : : : {np(dat)} + {xp(caus)}
duszno: pewny: : : : {np(dat)} + {xp(locat)}
duszno: pewny: : : : {xp(caus)} + {xp(locat)}
dziwnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
dziwnie: pewny: : : : {np(dat)} + {cp(gdy)}
dziwnie: potoczny: : : : {np(dat)} + {cp(jak)}
dziwnie: pewny: : : : {np(dat)} + {cp(jeśli)}
dziwnie: pewny: : : : {np(dat)} + {cp(kiedy)}
dziwnie: pewny: : : : {np(dat)} + {cp(że)}
dziwnie: pewny: : : : {np(dat)} + {prepnp(w,acc)}
dziwnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
dziwnie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
dziwnie: pewny: : : : {np(dat)} + {xp(locat)}
dziwno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
dziwno: pewny: : : : {np(dat)} + {cp(int)}
dziwno: pewny: : : : {np(dat)} + {cp(że)}
dziwno: pewny: : : : {np(dat)} + {xp(caus)}
ekstra: pewny: : : : {cp(gdy)}
ekstra: potoczny: : : : {cp(jak)}
ekstra: pewny: : : : {cp(jeśli)}
ekstra: pewny: : : : {cp(kiedy)}
ekstra: pewny: : : : {cp(że)}
ekstra: pewny: : : : {infp(_)}
elegancko: pewny: : : : {comprepnp(w stosunku do)} + {infp(_)}
elegancko: pewny: : : : {cp(gdy)}
elegancko: potoczny: : : : {cp(jak)}
elegancko: pewny: : : : {cp(jeśli)}
elegancko: pewny: : : : {cp(kiedy)}
elegancko: pewny: : : : {cp(że)}
elegancko: pewny: : : : {prepnp(wobec,gen)} + {infp(_)}
elegancko: pewny: : : : {prepnp(względem,gen)} + {infp(_)}
fajnie: wątpliwy: : : : {comprepnp(pod względem)}
fajnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
fajnie: pewny: : : : {cp(gdy)}
fajnie: potoczny: : : : {cp(jak)}
fajnie: pewny: : : : {cp(jeśli)}
fajnie: pewny: : : : {cp(kiedy)}
fajnie: pewny: : : : {np(dat)} + {cp(że)}
fajnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
fajnie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
fajnie: pewny: : : : {xp(locat)}
fajno: pewny: : : : {cp(gdy)}
fajno: potoczny: : : : {cp(jak)}
fajno: pewny: : : : {cp(jeśli)}
fajno: pewny: : : : {cp(kiedy)}
fajno: pewny: : : : {cp(że)}
fajno: pewny: : : : {infp(_)}
fajno: pewny: : : : {np(dat)} + {prepnp(w,loc)}
fajno: pewny: : : : {np(dat)} + {prepnp(z,inst)}
fajno: pewny: : : : {xp(locat)}
fantastycznie: pewny: : : : {cp(gdy)}
fantastycznie: potoczny: : : : {cp(jak)}
fantastycznie: pewny: : : : {cp(jeśli)}
fantastycznie: pewny: : : : {cp(kiedy)}
fantastycznie: pewny: : : : {cp(że)}
fantastycznie: pewny: : : : {infp(_)}
fantastycznie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
fantastycznie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
fatalnie: pewny: : : : {comprepnp(pod względem)}
fatalnie: pewny: : : : {cp(gdy)}
fatalnie: potoczny: : : : {cp(jak)}
fatalnie: pewny: : : : {cp(jeśli)}
fatalnie: pewny: : : : {cp(kiedy)}
fatalnie: pewny: : : : {infp(_)}
fatalnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
fatalnie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
fatalnie: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
genialnie: pewny: : : : {comprepnp(pod względem)}
genialnie: pewny: : : : {cp(gdy)}
genialnie: pewny: : : : {cp(jak)}
genialnie: pewny: : : : {cp(jeśli)}
genialnie: pewny: : : : {cp(kiedy)}
genialnie: pewny: : : : {cp(że)}
genialnie: pewny: : : : {infp(_)}
genialnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
genialnie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
genialnie: pewny: : : : {xp(mod[advp(mod)])}
głodno: pewny: : : : {np(dat)}
głodno: pewny: : : : {xp(locat)}
głośno: pewny: : : : {comprepnp(na temat)} + {xp(caus)} + {xp(locat)}
głośno: pewny: : : : {cp(że)} + {xp(locat)}
głośno: pewny: : : : {prepnp(o,loc)} + {comprepnp(ze względu na)} + {xp(locat)}
głośno: pewny: : : : {prepnp(o,loc);prepncp(o,loc,int);prepncp(o,loc,że)} + {comprepnp(za sprawą)} + {xp(locat)}
głośno: pewny: : : : {prepnp(o,loc);prepncp(o,loc,int);prepncp(o,loc,że)} + {xp(caus)} + {xp(locat)}
głucho: pewny: : : : {comprepnp(na temat)} + {xp(locat)}
głucho: pewny: : : : {np(dat)} + {prepnp(w,loc)}
głucho: pewny: : : : {prepnp(o,loc);prepncp(o,loc,int);prepncp(o,loc,że)} + {xp(locat)}
głupio: pewny: : : : controller{np(dat)} + controllee{infp(_)}
głupio: pewny: : : : {np(dat)} + {comprepnp(w stosunku do)} + {cp(że)}
głupio: pewny: : : : {np(dat)} + {comprepnp(w stosunku do)} + {xp(caus)}
głupio: pewny: : : : {np(dat)} + {cp(gdy)}
głupio: pewny: : : : {np(dat)} + {cp(jeśli)}
głupio: pewny: : : : {np(dat)} + {prepnp(przed,inst)} + {cp(kiedy)}
głupio: pewny: : : : {np(dat)} + {prepnp(przed,inst)} + {cp(że)}
głupio: pewny: : : : {np(dat)} + {prepnp(przed,inst)} + {xp(caus)}
głupio: pewny: : : : {np(dat)} + {prepnp(wobec,gen)} + {cp(kiedy)}
głupio: pewny: : : : {np(dat)} + {prepnp(wobec,gen)} + {cp(że)}
głupio: pewny: : : : {np(dat)} + {prepnp(wobec,gen)} + {cp(żeby)}
głupio: pewny: : : : {np(dat)} + {prepnp(wobec,gen)} + {xp(caus)}
głupio: pewny: : : : {np(dat)} + {prepnp(za,acc)} + {comprepnp(w stosunku do)}
głupio: pewny: : : : {np(dat)} + {prepnp(za,acc)} + {cp(jak)}
głupio: pewny: : : : {np(dat)} + {prepnp(za,acc)} + {cp(że)}
gorąco: pewny: : : : {np(dat)} + {prepnp(po,loc)} + {prepnp(w,acc)}
gorąco: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {prepnp(w,loc)}
gorąco: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {xp(caus)}
gorąco: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {xp(locat)}
gorzko: pewny: : : : controller{np(dat)} + controllee{infp(_)}
gorzko: pewny: : : : {np(dat)} + {cp(gdy)}
gorzko: potoczny: : : : {np(dat)} + {cp(jak)}
gorzko: pewny: : : : {np(dat)} + {cp(jeśli)}
gorzko: pewny: : : : {np(dat)} + {cp(kiedy)}
gorzko: pewny: : : : {np(dat)} + {prepnp(od,gen)} + {xp(locat)}
gorzko: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,że)}
gorzko: pewny: : : : {np(dat)} + {xp(caus)}
idealnie: pewny: : : : {comprepnp(pod względem)}
idealnie: pewny: : : : {cp(gdy)}
idealnie: potoczny: : : : {cp(jak)}
idealnie: pewny: : : : {cp(jeśli)}
idealnie: pewny: : : : {cp(kiedy)}
idealnie: pewny: : : : {cp(że)}
idealnie: pewny: : : : {infp(_)}
identycznie: pewny: : : : {compar(co)} + {comprepnp(pod względem)}
identycznie: pewny: : : : {compar(jak)} + {comprepnp(pod względem)}
identycznie: wątpliwy: : : : {comprepnp(w stosunku do)}
identycznie: pewny: : : : {prepnp(co do,gen)} + {prepnp(z,inst)}
identycznie: pewny: : : : {prepnp(do,gen)} + {comprepnp(pod względem)}
identycznie: pewny: : : : {prepnp(z,inst)} + {comprepnp(pod względem)}
jasno: pewny: : : : {comprepnp(pod względem)}
jasno: wątpliwy: : : : {np(dat)}
jasno: pewny: : : : {xp(locat)}
jasno: pewny: : : : {xp(mod[advp(mod)])}
jednocześnie: pewny: : : : {prepnp(z,inst)}
kapitalnie: pewny: : : : {comprepnp(pod względem)}
kapitalnie: pewny: : : : {cp(gdy)}
kapitalnie: potoczny: : : : {cp(jak)}
kapitalnie: pewny: : : : {cp(jeśli)}
kapitalnie: pewny: : : : {cp(kiedy)}
kapitalnie: pewny: : : : {cp(że)}
kapitalnie: pewny: : : : {infp(_)}
kapitalnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
kapitalnie: pewny: : : : {xp(mod[advp(mod)])}
kiepsko: pewny: : : : {comprepnp(pod względem)}
kiepsko: pewny: : : : {cp(gdy)}
kiepsko: potoczny: : : : {cp(jak)}
kiepsko: pewny: : : : {cp(jeśli)}
kiepsko: pewny: : : : {cp(że)}
kiepsko: pewny: : : : {infp(_)}
kiepsko: pewny: : : : {prepnp(u,gen)} + {prepnp(z,inst)}
kiepsko: pewny: : : : {prepnp(z,inst)} + {xp(locat)}
klawo: pewny: : : : {cp(gdy)}
klawo: potoczny: : : : {cp(jak)}
klawo: pewny: : : : {cp(kiedy)}
klawo: pewny: : : : {cp(że)}
klawo: pewny: : : : {infp(_)}
klawo: pewny: : : : {np(dat)}
krucho: pewny: : : : {comprepnp(pod względem)} + {xp(locat)}
krucho: pewny: : : : {np(dat)} + {xp(locat)}
krucho: pewny: : : : {prepnp(z,inst)} + {xp(locat)}
krucho: pewny: : : : {xp(locat)} + {xp(mod[advp(mod)])}
lekko: pewny: : : : controller{np(dat)} + controllee{infp(_)}
lekko: pewny: : : : {np(dat)} + {cp(gdy)}
lekko: potoczny: : : : {np(dat)} + {cp(jak)}
lekko: pewny: : : : {np(dat)} + {cp(jeśli)}
lekko: pewny: : : : {np(dat)} + {cp(kiedy)}
lekko: pewny: : : : {np(dat)} + {cp(że)}
lekko: pewny: : : : {np(dat)} + {prepnp(przez,acc);prepncp(przez,acc,że)}
lekko: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,int);prepncp(z,inst,że)}
lekko: pewny: : : : {np(dat)} + {xp(caus)}
lekko: pewny: : : : {np(dat)} + {xp(locat)}
lodowato: pewny: : : : {np(dat)} + {prepnp(od,gen)} + {prepnp(w,acc)}
lodowato: pewny: : : : {xp(locat)}
lubo: pewny: : : : controller{np(dat)} + controllee{infp(_)}
lubo: pewny: : : : {np(dat)} + {cp(gdy)}
lubo: pewny: : : : {np(dat)} + {cp(kiedy)}
luźno: pewny: : : : {np(dat)} + {xp(locat)}
ładnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
ładnie: pewny: : : : {cp(gdy)}
ładnie: potoczny: : : : {cp(jak)}
ładnie: pewny: : : : {cp(jeśli)}
ładnie: pewny: : : : {cp(kiedy)}
ładnie: pewny: : : : {infp(_)}
ładnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
ładnie: pewny: : : : {prepnp(dla,gen)}
ładnie: pewny: : : : {xp(locat)}
łatwo: pewny: : : : controller{np(dat)} + controllee{infp(_)}
łatwo: pewny: : : : {np(dat)} + {cp(żeby)}
łatwo: pewny: : : : {np(dat)} + {prepnp(o,acc);prepncp(o,acc,żeby)}
łatwo: pewny: : : : {prepnp(o,acc)} + {xp(locat)}
łyso: pewny: : : : controller{np(dat)} + controllee{infp(_)}
łyso: pewny: : : : {np(dat)} + {cp(gdy)}
łyso: potoczny: : : : {np(dat)} + {cp(jak)}
łyso: pewny: : : : {np(dat)} + {cp(kiedy)}
łyso: pewny: : : : {np(dat)} + {cp(że)}
łyso: pewny: : : : {np(dat)} + {prepnp(za,acc)}
łyso: pewny: : : : {np(dat)} + {xp(caus)}
łyso: pewny: : : : {np(dat)} + {xp(locat)}
mało: pewny: : : : {np(dat)} + {cp(że)}
mało: pewny: : : : {np(dat)} + {np(gen);ncp(gen,int);ncp(gen,że)}
małodusznie: pewny: : pred: : {infp(_)}
markotnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
markotnie: pewny: : : : {np(dat)} + {cp(gdy)}
markotnie: potoczny: : : : {np(dat)} + {cp(jak)}
markotnie: pewny: : : : {np(dat)} + {cp(kiedy)}
markotnie: pewny: : : : {np(dat)} + {cp(że)}
markotnie: pewny: : : : {np(dat)} + {xp(caus)}
markotnie: pewny: : : : {np(dat)} + {xp(locat)}
markotno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
markotno: pewny: : : : {np(dat)} + {cp(gdy)}
markotno: potoczny: : : : {np(dat)} + {cp(jak)}
markotno: pewny: : : : {np(dat)} + {cp(kiedy)}
markotno: pewny: : : : {np(dat)} + {cp(że)}
markotno: pewny: : : : {np(dat)} + {xp(caus)}
markotno: pewny: : : : {np(dat)} + {xp(locat)}
mądrze: pewny: : : : {comprepnp(od strony)}
mądrze: pewny: : : : {comprepnp(pod względem)}
mądrze: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
mądrze: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
mądrze: wątpliwy: : : : {prepnp(co do,gen)}
mądrze: pewny: : : : {xp(mod[advp(mod)])}
mdło: pewny: : : : {np(dat)} + {xp(caus)}
mdło: pewny: : : : {prepnp(od,gen)} + {xp(locat)}
miękko: pewny: : : : controller{np(dat)} + controllee{infp(_)}
miękko: pewny: : : : {np(dat)} + {prepnp(w,acc)}
miękko: pewny: : : : {np(dat)} + {prepnp(w,loc)}
miękko: pewny: : : : {np(dat)} + {xp(locat)}
miło: pewny: : : : {comprepnp(ze strony)} + {cp(gdy)}
miło: potoczny: : : : {comprepnp(ze strony)} + {cp(jak)}
miło: pewny: : : : {comprepnp(ze strony)} + {cp(jeśli)}
miło: pewny: : : : {comprepnp(ze strony)} + {cp(kiedy)}
miło: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
miło: pewny: : : : controller{np(dat)} + controllee{infp(_)}
miło: pewny: : : : {np(dat)} + {cp(gdy)}
miło: potoczny: : : : {np(dat)} + {cp(jak)}
miło: pewny: : : : {np(dat)} + {cp(jeśli)}
miło: pewny: : : : {np(dat)} + {cp(kiedy)}
miło: pewny: : : : {np(dat)} + {cp(że)}
miło: pewny: : : : {np(dat)} + {xp(caus)}
miło: pewny: : : : {prepnp(dla,gen)}
modnie: pewny: : : : {infp(_)}
mroczno: pewny: : : : {np(dat)} + {prepnp(na,loc)}
mroczno: pewny: : : : {xp(locat)}
naiwnie: pewny: : : : {comprepnp(pod wpływem)}
naiwnie: pewny: : : : {infp(_)}
naiwnie: pewny: : : : {xp(mod[advp(mod)])}
naprzód: pewny: : : : {np(acc)}
naprzód: pewny: : : : {prepnp(do,gen)}
naturalnie: pewny: : : : {cp(że)}
niebezpiecznie: pewny: : : : {comprepnp(pod względem)}
niebezpiecznie: pewny: : : : {comprepnp(ze względu na)}
niebezpiecznie: pewny: : : : {comprepnp(z powodu)}
niebezpiecznie: pewny: : : : {infp(_)}
niebezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
niebezpiecznie: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
niebezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
niebezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
niebezpiecznie: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
niebezpiecznie: pewny: : : : {xp(mod[advp(mod)])}
nieciekawie: potoczny: : : : {comprepnp(pod względem)}
nieciekawie: pewny: : : : {infp(_)}
nieciekawie: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
nieciekawie: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
nieciekawie: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
nieciekawie: pewny: : : : {prepnp(dla,gen)} + {xp(locat)}
nieciekawie: pewny: : : : {xp(mod[advp(mod)])}
niedaleko: pewny: : : : {comprepnp(w stosunku do)}
niedaleko: pewny: : : : {np(dat)} + {prepnp(do,gen)} + {prepnp(od,gen)}
niedaleko: pewny: : : : {prepnp(dla,gen)}
niedaleko: pewny: : : : {prepnp(względem,gen)}
niedaleko: pewny: : : : {xp(abl)} + {xp(adl)}
niedelikatnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
niedelikatnie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
niedobrze: pewny: : : : controller{np(dat)} + controllee{infp(_)}
niedobrze: pewny: : : : {np(dat)} + {cp(gdy)}
niedobrze: potoczny: : : : {np(dat)} + {cp(jak)}
niedobrze: pewny: : : : {np(dat)} + {cp(jeśli)}
niedobrze: pewny: : : : {np(dat)} + {cp(kiedy)}
niedobrze: pewny: : : : {np(dat)} + {prepnp(w,loc)}
niedobrze: pewny: : : : {np(dat)} + {prepnp(z,inst)}
niedobrze: pewny: : : : {np(dat)} + {xp(caus)}
niedobrze: pewny: : : : {np(dat)} + {xp(locat)}
niedobrze: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
niedobrze: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
niedobrze: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
niedobrze: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
niedobrze: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
niedobrze: pewny: : : : {prepnp(dla,gen)} + {cp(żeby)}
niedobrze: pewny: : : : {prepnp(u,gen)} + {prepnp(z,inst)}
niedorzecznie: pewny: : : : {infp(_)}
niedorzecznie: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
nieelegancko: pewny: : : : {comprepnp(w stosunku do)} + {infp(_)}
nieelegancko: pewny: : : : {cp(gdy)}
nieelegancko: potoczny: : : : {cp(jak)}
nieelegancko: pewny: : : : {cp(jeśli)}
nieelegancko: pewny: : : : {cp(kiedy)}
nieelegancko: pewny: : : : {cp(że)}
nieelegancko: pewny: : : : {cp(żeby)}
nieelegancko: pewny: : : : {prepnp(wobec,gen)} + {infp(_)}
nieelegancko: pewny: : : : {prepnp(względem,gen)} + {infp(_)}
niefortunnie: pewny: : : : {cp(że)}
niefortunnie: pewny: : : : {infp(_)}
niefortunnie: pewny: : : : {prepnp(dla,gen)}
niegodziwie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
niegodziwie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
niegrzecznie: pewny: : pred: : {comprepnp(w stosunku do)} + {cp(że)}
niegrzecznie: pewny: : pred: : {comprepnp(ze strony)} + {cp(gdy)}
niegrzecznie: potoczny: : pred: : {comprepnp(ze strony)} + {cp(jak)}
niegrzecznie: pewny: : pred: : {comprepnp(ze strony)} + {cp(kiedy)}
niegrzecznie: pewny: : pred: : {comprepnp(ze strony)} + {cp(że)}
niegrzecznie: pewny: : pred: : {comprepnp(ze strony)} + {infp(_)}
niegrzecznie: pewny: : pred: : {prepnp(wobec,gen)} + {cp(że)}
niegrzecznie: pewny: : pred: : {prepnp(względem,gen)} + {cp(że)}
niekorzystnie: pewny: : : : {prepnp(dla,gen)} + {comprepnp(pod względem)}
niekorzystnie: pewny: : : : {prepnp(dla,gen)} + {infp(_)}
niekorzystnie: pewny: : : : {prepnp(dla,gen)} + {xp(mod[advp(mod)])}
nielekko: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nielekko: pewny: : : : {np(dat)} + {prepnp(z,inst)}
nielekko: pewny: : : : {np(dat)} + {xp(locat)}
nielogicznie: wątpliwy: : : : {cp(że)}
nielogicznie: pewny: : : : {infp(_)}
nieładnie: pewny: : : : {comprepnp(w stosunku do)}
nieładnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
nieładnie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
nieładnie: pewny: : : : {cp(gdy)}
nieładnie: potoczny: : : : {cp(jak)}
nieładnie: pewny: : : : {cp(jeśli)}
nieładnie: pewny: : : : {cp(kiedy)}
nieładnie: pewny: : : : {cp(żeby)}
nieładnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
nieładnie: pewny: : : : {prepnp(wobec,gen)} + {infp(_)}
nieładnie: pewny: : : : {xp(locat)}
niełatwo: pewny: : : : controller{np(dat)} + controllee{infp(_)}
niełatwo: pewny: : : : {np(dat)} + {cp(żeby)}
niełatwo: pewny: : : : {np(dat)} + {prepnp(o,acc);prepncp(o,acc,żeby)}
niełatwo: pewny: : : : {prepnp(o,acc)} + {xp(locat)}
niemądrze: pewny: : : : {comprepnp(od strony)}
niemądrze: pewny: : : : {comprepnp(pod względem)}
niemądrze: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
niemądrze: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
niemądrze: pewny: : : : {xp(mod[advp(mod)])}
niemile: pewny: : : : controller{np(dat)} + controllee{infp(_)}
niemile: pewny: : : : {prepnp(dla,gen)}
niemiło: pewny: : : : controller{np(dat)} + controllee{infp(_)}
niemiło: pewny: : : : {np(dat)} + {cp(gdy)}
niemiło: potoczny: : : : {np(dat)} + {cp(jak)}
niemiło: pewny: : : : {np(dat)} + {cp(jeśli)}
niemiło: pewny: : : : {np(dat)} + {cp(kiedy)}
niemiło: pewny: : : : {np(dat)} + {cp(że)}
niemiło: pewny: : : : {np(dat)} + {xp(caus)}
niemiło: pewny: : : : {np(dat)} + {xp(locat)}
niemiło: pewny: : : : {prepnp(dla,gen)}
nieporęcznie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nieporęcznie: pewny: : : : {np(dat)} + {prepnp(z,inst)} + {xp(locat)}
nieporęcznie: pewny: : : : {prepnp(dla,gen)}
nieprzyjemnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nieprzyjemnie: pewny: : : : {np(dat)} + {comprepnp(ze względu na)}
nieprzyjemnie: pewny: : : : {np(dat)} + {cp(gdy)}
nieprzyjemnie: potoczny: : : : {np(dat)} + {cp(jak)}
nieprzyjemnie: pewny: : : : {np(dat)} + {cp(jeśli)}
nieprzyjemnie: pewny: : : : {np(dat)} + {cp(kiedy)}
nieprzyjemnie: pewny: : : : {np(dat)} + {cp(że)}
nieprzyjemnie: pewny: : : : {np(dat)} + {prepnp(przed,inst)}
nieprzyjemnie: pewny: : : : {np(dat)} + {xp(caus)}
nieprzyjemnie: pewny: : : : {prepnp(dla,gen)}
nieprzyjemnie: pewny: : : : {prepnp(między,inst)}
nieracjonalnie: pewny: : : : {infp(_)}
nierozsądnie: pewny: : : : {comprepnp(pod względem)}
nierozsądnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
nierozsądnie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
nierozsądnie: pewny: : : : {xp(mod[advp(mod)])}
nieroztropnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
nieroztropnie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
nierozważnie: pewny: : : : {cp(że)}
nierozważnie: pewny: : : : {infp(_)}
nieskoro: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nieskoro: pewny: : : : {np(dat)} + {prepnp(do,gen)}
niesłusznie: pewny: : : : {comprepnp(pod względem)}
niesłusznie: pewny: : : : {cp(że)}
niesłusznie: pewny: : : : {cp(żeby)}
niesłusznie: pewny: : : : {infp(_)}
niesłusznie: pewny: : : : {xp(mod[advp(mod)])}
niespieszno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
niespieszno: pewny: : : : {np(dat)} + {cp(żeby)}
niespieszno: pewny: : : : {np(dat)} + {prepnp(do,gen);prepncp(do,gen,żeby)}
niespieszno: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,żeby)}
niespieszno: pewny: : : : {np(dat)} + {xp(adl)}
niesporo: pewny: : : : controller{np(dat)} + controllee{infp(_)}
niesporo: pewny: : : : {np(dat)} + {cp(że)}
nieswojo: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nieswojo: pewny: : : : {np(dat)} + {cp(gdy)}
nieswojo: potoczny: : : : {np(dat)} + {cp(jak)}
nieswojo: pewny: : : : {np(dat)} + {cp(jeśli)}
nieswojo: pewny: : : : {np(dat)} + {cp(kiedy)}
nieswojo: pewny: : : : {np(dat)} + {cp(że)}
nieswojo: pewny: : : : {np(dat)} + {prepnp(przez,acc);prepncp(przez,acc,że)}
nieswojo: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,int);prepncp(z,inst,że)}
nieswojo: pewny: : : : {np(dat)} + {xp(caus)}
nieswojo: pewny: : : : {np(dat)} + {xp(locat)}
nieśpieszno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nieśpieszno: pewny: : : : {np(dat)} + {cp(żeby)}
nieśpieszno: pewny: : : : {np(dat)} + {prepnp(do,gen);prepncp(do,gen,żeby)}
nieśpieszno: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,żeby)}
nieśpieszno: pewny: : : : {np(dat)} + {xp(adl)}
nietaktownie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
nietaktownie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
nietrudno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nietrudno: pewny: : : : {cp(żeby)}
nietrudno: pewny: : : : {np(dat)} + {prepnp(o,acc);prepncp(o,acc,żeby)}
nietrudno: pewny: : : : {prepnp(o,acc);prepncp(o,acc,żeby)} + {xp(locat)}
niewesoło: pewny: : : : {comprepnp(pod względem)} + {xp(locat)}
niewesoło: wątpliwy: : : : {np(dat)} + {comprepnp(za sprawą)}
niewesoło: pewny: : : : {np(dat)} + {cp(gdy)}
niewesoło: potoczny: : : : {np(dat)} + {cp(jak)}
niewesoło: pewny: : : : {np(dat)} + {cp(jeśli)}
niewesoło: pewny: : : : {np(dat)} + {cp(kiedy)}
niewesoło: pewny: : : : {np(dat)} + {cp(że)}
niewesoło: pewny: : : : {np(dat)} + {xp(caus)}
niewesoło: pewny: : : : {np(dat)} + {xp(locat)}
niewesoło: pewny: : : : {prepnp(dla,gen)}
niewesoło: wątpliwy: : : : {prepnp(wobec,gen)} + {xp(locat)}
niewesoło: pewny: : : : {prepnp(z,inst)} + {xp(locat)}
niewłaściwie: pewny: : : : {comprepnp(pod względem)}
niewłaściwie: pewny: : : : {xp(mod[advp(mod)])}
niewłaściwie: pewny: : pred: : {infp(_)}
niewygodnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
niewygodnie: pewny: : : : {np(dat)} + {cp(gdy)}
niewygodnie: potoczny: : : : {np(dat)} + {cp(jak)}
niewygodnie: pewny: : : : {np(dat)} + {cp(jeśli)}
niewygodnie: pewny: : : : {np(dat)} + {cp(kiedy)}
niewygodnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
niewygodnie: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,int);prepncp(z,inst,że)}
niewygodnie: pewny: : : : {np(dat)} + {prepnp(z,inst)} + {xp(locat)}
niewygodnie: pewny: : : : {prepnp(dla,gen)}
niewyraźnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
niewyraźnie: pewny: : : : {np(dat)} + {xp(locat)}
niezależnie: pewny: : : : {comprepnp(pod względem)}
niezależnie: pewny: : : : {cp(int)}
niezależnie: potoczny: : : : {cp(że)}
niezależnie: wątpliwy: : : : {prepnp(do,gen)}
niezależnie: pewny: : : : {prepnp(od,gen);prepncp(od,gen,int);prepncp(od,gen,że)}
niezależnie: pewny: : : : {xp(mod[advp(mod)])}
niezdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
niezdrowo: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
niezdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
niezdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
niezdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
niezdrowo: pewny: : : : {prepnp(dla,gen)} + {infp(_)}
niezręcznie: pewny: : : : {comprepnp(pod względem)}
niezręcznie: pewny: : : : {xp(mod[advp(mod)])}
niezręcznie: pewny: : pred: : controller{np(dat)} + controllee{infp(_)}
niezręcznie: pewny: : pred: : {np(dat)} + {comprepnp(w stosunku do)}
niezręcznie: pewny: : pred: : {np(dat)} + {comprepnp(ze względu na)}
niezręcznie: pewny: : pred: : {np(dat)} + {cp(gdy)}
niezręcznie: potoczny: : pred: : {np(dat)} + {cp(jak)}
niezręcznie: pewny: : pred: : {np(dat)} + {cp(kiedy)}
niezręcznie: pewny: : pred: : {np(dat)} + {cp(że)}
niezręcznie: pewny: : pred: : {np(dat)} + {prepnp(wobec,gen)}
niezręcznie: pewny: : pred: : {np(dat)} + {prepnp(względem,gen)}
niezręcznie: pewny: : pred: : {np(dat)} + {xp(caus)}
nieźle: pewny: : : : {comprepnp(pod względem)}
nieźle: pewny: : : : {cp(gdy)}
nieźle: potoczny: : : : {cp(jak)}
nieźle: pewny: : : : {cp(jeśli)}
nieźle: pewny: : : : {cp(kiedy)}
nieźle: pewny: : : : {cp(że)}
nieźle: pewny: : : : {infp(_)}
nieźle: pewny: : : : {np(dat)} + {prepnp(w,loc)}
nieźle: pewny: : : : {np(dat)} + {prepnp(z,inst)}
nieźle: pewny: : : : {xp(mod[advp(mod)])}
nijako: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nijako: pewny: : : : {np(dat)} + {prepnp(z,inst)}
normalnie: pewny: : : : {infp(_)}
normalnie: pewny: : : : {np(dat)}
nudno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
nudno: wątpliwy: : : : {np(dat)} + {cp(że)}
nudno: pewny: : : : {np(dat)} + {xp(locat)}
obocznie: wątpliwy: : : : {comprepnp(w stosunku do)}
obocznie: pewny: : : : {prepnp(do,gen)}
obocznie: wątpliwy: : : : {prepnp(wobec,gen)}
obocznie: wątpliwy: : : : {prepnp(względem,gen)}
obocznie: pewny: : : : {prepnp(z,inst)}
obojętnie: pewny: : : : {np(dat)} + {cp(int)}
oczywista: pewny: : : : {cp(że)}
oczywiście: pewny: : : : {cp(że)}
odpowiednio: pewny: : : : {comprepnp(pod względem)}
odpowiednio: pewny: : : : {cp(żeby)}
odpowiednio: pewny: : : : {infp(_)}
odpowiednio: pewny: : : : {prepnp(dla,gen)}
odpowiednio: pewny: : : : {prepnp(do,gen);prepncp(do,gen,int)}
odpowiednio: pewny: : : : {xp(mod[advp(mod)])}
odwrotnie: potoczny: : : : {compar(jak)}
odwrotnie: pewny: : : : {compar(niż)}
odwrotnie: pewny: : : : {comprepnp(w stosunku do)}
odwrotnie: wątpliwy: : : : {prepnp(co do,gen)}
odwrotnie: pewny: : : : {prepnp(do,gen)}
odwrotnie: wątpliwy: : : : {prepnp(od,gen)}
odwrotnie: pewny: : : : {prepnp(wobec,gen)}
odwrotnie: pewny: : : : {prepnp(względem,gen)}
okropnie: pewny: : : : {np(dat)} + {compar(jako)}
okropnie: pewny: : : : {np(dat)} + {comprepnp(z powodu)}
okropnie: pewny: : : : {np(dat)} + {cp(gdy)}
okropnie: potoczny: : : : {np(dat)} + {cp(jak)}
okropnie: pewny: : : : {np(dat)} + {cp(jeśli)}
okropnie: pewny: : : : {np(dat)} + {cp(kiedy)}
okropnie: pewny: : : : {np(dat)} + {cp(że)}
okropnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
okropnie: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,int);prepncp(z,inst,że)}
okropnie: pewny: : : : {np(dat)} + {xp(locat)}
ostrożnie: pewny: : : : {prepnp(przy,loc)}
ostrożnie: pewny: : : : {prepnp(z,inst)}
ostrożnie: pewny: : : : {xp(adl)}
ostrożnie: pewny: : : : {xp(locat)}
parno: pewny: : : : {xp(caus)} + {xp(locat)}
paskudnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
paskudnie: pewny: : : : {np(dat)} + {cp(gdy)}
paskudnie: potoczny: : : : {np(dat)} + {cp(jak)}
paskudnie: pewny: : : : {np(dat)} + {cp(jeśli)}
paskudnie: pewny: : : : {np(dat)} + {cp(kiedy)}
paskudnie: pewny: : : : {np(dat)} + {cp(że)}
paskudnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
paskudnie: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,int);prepncp(z,inst,że)}
paskudnie: pewny: : : : {np(dat)} + {xp(caus)}
paskudnie: pewny: : : : {np(dat)} + {xp(locat)}
pechowo: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
pełno: pewny: : : : {np(gen)} + {xp(locat)}
pewnie: pewny: : : : {comprepnp(pod względem)}
pewnie: pewny: : : : {cp(że)}
pewnie: potoczny: : : : {prepnp(co do,gen)}
pewno: pewny: : : : {cp(że)}
pięknie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
pięknie: pewny: : : : {cp(gdy)}
pięknie: potoczny: : : : {cp(jak)}
pięknie: pewny: : : : {cp(jeśli)}
pięknie: pewny: : : : {cp(kiedy)}
pięknie: pewny: : : : {cp(żeby)}
pięknie: pewny: : : : {infp(_)}
pięknie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
pięknie: pewny: : : : {prepnp(dla,gen)}
pięknie: pewny: : : : {xp(locat)}
pilno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
pilno: pewny: : : : {np(dat)} + {cp(żeby)}
pilno: pewny: : : : {np(dat)} + {prepnp(do,gen);prepncp(do,gen,żeby)}
pilno: pewny: : : : {np(dat)} + {xp(abl)}
pilno: pewny: : : : {np(dat)} + {xp(adl)}
podle: pewny: : : : {np(dat)}
podobnie: potoczny: : : : {compar(co)}
podobnie: pewny: : : : {compar(jak)}
podobnie: wątpliwy: : : : {prepnp(co do,gen)}
podobnie: pewny: : : : {prepnp(do,gen)}
ponuro: wątpliwy: : : : {comprepnp(pod względem)}
ponuro: pewny: : : : {np(dat)} + {xp(locat)}
poręcznie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
poręcznie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
poręcznie: pewny: : : : {np(dat)} + {xp(locat)}
poręcznie: pewny: : : : {prepnp(dla,gen)}
pożytecznie: wątpliwy: : : : {prepnp(dla,gen)} + {cp(że)}
pożytecznie: wątpliwy: : : : {prepnp(dla,gen)} + {cp(żeby)}
pożytecznie: pewny: : : : {prepnp(dla,gen)} + {infp(_)}
prawidłowo: pewny: : : : {comprepnp(od strony)}
prawidłowo: pewny: : : : {comprepnp(pod względem)}
prawidłowo: pewny: : : : {cp(gdy)}
prawidłowo: potoczny: : : : {cp(jak)}
prawidłowo: pewny: : : : {cp(jeśli)}
prawidłowo: pewny: : : : {cp(kiedy)}
prawidłowo: pewny: : : : {cp(że)}
prawidłowo: pewny: : : : {infp(_)}
prawidłowo: pewny: : : : {xp(mod[advp(mod)])}
prosto: pewny: : : : {comprepnp(pod względem)}
prosto: pewny: : pred: : {infp(_)}
prosto: pewny: : pred: : {prepnp(dla,gen)} + {cp(gdy)}
prosto: potoczny: : pred: : {prepnp(dla,gen)} + {cp(jak)}
prosto: pewny: : pred: : {prepnp(dla,gen)} + {cp(jeśli)}
prosto: pewny: : pred: : {prepnp(dla,gen)} + {cp(kiedy)}
prosto: potoczny: : pred: : {prepnp(dla,gen)} + {cp(że)}
prosto: pewny: : pred: : {prepnp(dla,gen)} + {cp(żeby)}
prosto: pewny: : pred: : {prepnp(o,acc)}
próżno: pewny: : : : {infp(imperf)}
przeciwnie: wątpliwy: : : : {compar(jak)}
przeciwnie: pewny: : : : {compar(niż)}
przeciwnie: pewny: : : : {comprepnp(w stosunku do)}
przeciwnie: archaiczny: : : : {np(dat)}
przeciwnie: pewny: : : : {prepnp(do,gen)}
przeciwnie: wątpliwy: : : : {prepnp(wobec,gen)}
przeciwnie: wątpliwy: : : : {prepnp(względem,gen)}
przyciasno: pewny: : : : {np(dat)} + {prepnp(w,loc)}
przyciasno: pewny: : : : {np(dat)} + {xp(locat)}
przyciężko: pewny: : : : controller{np(dat)} + controllee{infp(_)}
przyjemnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
przyjemnie: pewny: : : : {np(dat)} + {cp(gdy)}
przyjemnie: potoczny: : : : {np(dat)} + {cp(jak)}
przyjemnie: pewny: : : : {np(dat)} + {cp(jeśli)}
przyjemnie: pewny: : : : {np(dat)} + {cp(kiedy)}
przyjemnie: pewny: : : : {np(dat)} + {cp(że)}
przyjemnie: pewny: : : : {np(dat)} + {xp(locat)}
przyjemnie: wątpliwy: : : : {prepnp(dla,gen)} + {infp(_)}
przykro: pewny: : : : controller{np(dat)} + controllee{infp(_)}
przykro: pewny: : : : {np(dat)} + {cp(gdy)}
przykro: potoczny: : : : {np(dat)} + {cp(jak)}
przykro: pewny: : : : {np(dat)} + {cp(jeśli)}
przykro: pewny: : : : {np(dat)} + {cp(kiedy)}
przykro: pewny: : : : {np(dat)} + {cp(że)}
przykro: wątpliwy: : : : {np(dat)} + {prepnp(przed,inst)}
przykro: pewny: : : : {np(dat)} + {prepnp(przez,acc);prepncp(przez,acc,int);prepncp(przez,acc,że)}
przykro: wątpliwy: : : : {np(dat)} + {prepnp(wobec,gen)}
przykro: pewny: : : : {np(dat)} + {prepnp(za,acc);prepncp(za,acc,int);prepncp(za,acc,że)}
przykro: zły: : : : {np(dat)} + {prepnp(z,gen)}
przykro: pewny: : : : {np(dat)} + {xp(caus)}
przytulnie: pewny: : : : {np(dat)} + {xp(locat)}
pstro: pewny: : : : {np(dat)} + {xp(locat)}
pstro: pewny: : : : {prepnp(od,gen)} + {xp(locat)}
pysznie: pewny: : : : {cp(że)}
pysznie: pewny: : : : {infp(_)}
pysznie: pewny: : : : {np(dat)} + {xp(locat)}
radośnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
radośnie: pewny: : : : {np(dat)} + {cp(gdy)}
radośnie: potoczny: : : : {np(dat)} + {cp(jak)}
radośnie: pewny: : : : {np(dat)} + {cp(kiedy)}
radośnie: pewny: : : : {np(dat)} + {cp(że)}
radośnie: pewny: : : : {prepnp(dla,gen)}
raźno: pewny: : : : {np(dat)} + {cp(gdy)}
raźno: potoczny: : : : {np(dat)} + {cp(jak)}
raźno: pewny: : : : {np(dat)} + {cp(jeśli)}
raźno: pewny: : : : {np(dat)} + {cp(kiedy)}
raźno: pewny: : : : {np(dat)} + {cp(że)}
raźno: pewny: : : : {np(dat)} + {xp(locat)}
rozkosznie: pewny: : : : {cp(że)}
rozkosznie: pewny: : : : {infp(_)}
rozkosznie: pewny: : : : {np(dat)}
rozsądnie: pewny: : : : {comprepnp(pod względem)}
rozsądnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
rozsądnie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
rozsądnie: pewny: : : : {xp(mod[advp(mod)])}
roztropnie: pewny: : : : {comprepnp(ze strony)} + {cp(że)}
roztropnie: pewny: : : : {comprepnp(ze strony)} + {infp(_)}
rozumnie: pewny: : pred: : {infp(_)}
równiutko: pewny: : : : {comprepnp(w stosunku do)}
równiutko: pewny: : : : {prepnp(co do,gen)}
równiutko: pewny: : : : {prepnp(wobec,gen)}
równiutko: pewny: : : : {prepnp(względem,gen)}
równiutko: pewny: : : : {prepnp(z,inst)}
równiutko: pewny: : : : {xp(temp)}
równo: pewny: : : : {comprepnp(pod względem)}
równo: pewny: : : : {comprepnp(w stosunku do)}
równo: pewny: : : : {prepnp(co do,gen)}
równo: pewny: : : : {prepnp(wobec,gen)}
równo: pewny: : : : {prepnp(względem,gen)}
równo: pewny: : : : {prepnp(z,inst)}
równo: pewny: : : : {xp(temp)}
równocześnie: pewny: : : : {prepnp(do,gen)}
równocześnie: pewny: : : : {prepnp(z,inst)}
rześko: pewny: : : : {np(dat)}
rześko: pewny: : : : {xp(locat)}
rzewnie: pewny: : : : {np(dat)}
samotnie: pewny: : : : controller{np(dat)} + controllee{infp(imperf)}
samotnie: pewny: : : : {np(dat)} + {xp(locat)}
sensownie: pewny: : : : {cp(że)}
sensownie: pewny: : : : {cp(żeby)}
sensownie: pewny: : : : {prepnp(dla,gen)} + {infp(_)}
słabo: pewny: : : : {np(dat)} + {cp(gdy)}
słabo: potoczny: : : : {np(dat)} + {cp(jak)}
słabo: pewny: : : : {np(dat)} + {cp(jeśli)}
słabo: pewny: : : : {np(dat)} + {cp(kiedy)}
słabo: pewny: : : : {np(dat)} + {xp(caus)}
słodko: pewny: : : : {np(dat)} + {cp(że)}
słusznie: pewny: : : : {comprepnp(pod względem)}
słusznie: pewny: : : : {cp(że)}
słusznie: pewny: : : : {cp(żeby)}
słusznie: pewny: : : : {infp(_)}
słusznie: pewny: : : : {xp(mod[advp(mod)])}
smutno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
smutno: pewny: : : : {np(dat)} + {cp(gdy)}
smutno: potoczny: : : : {np(dat)} + {cp(jak)}
smutno: pewny: : : : {np(dat)} + {cp(jeśli)}
smutno: pewny: : : : {np(dat)} + {cp(kiedy)}
smutno: pewny: : : : {np(dat)} + {cp(że)}
smutno: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,int);prepncp(z,inst,że)}
smutno: pewny: : : : {np(dat)} + {xp(caus)}
smutno: pewny: : : : {np(dat)} + {xp(locat)}
spieszno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
spieszno: pewny: : : : {np(dat)} + {cp(żeby)}
spieszno: pewny: : : : {np(dat)} + {prepnp(do,gen);prepncp(do,gen,żeby)}
spieszno: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,żeby)}
spieszno: wątpliwy: : : : {np(dat)} + {xp(abl)}
spieszno: pewny: : : : {np(dat)} + {xp(adl)}
stąd: pewny: : : : {cp(że)}
strasznie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
strasznie: pewny: : : : {np(dat)} + {cp(gdy)}
strasznie: potoczny: : : : {np(dat)} + {cp(jak)}
strasznie: pewny: : : : {np(dat)} + {cp(kiedy)}
strasznie: pewny: : : : {np(dat)} + {cp(że)}
strasznie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
strasznie: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,że)}
strasznie: pewny: : : : {np(dat)} + {xp(locat)}
straszno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
straszno: pewny: : : : {np(dat)} + {cp(gdy)}
straszno: potoczny: : : : {np(dat)} + {cp(jak)}
straszno: pewny: : : : {np(dat)} + {cp(kiedy)}
straszno: pewny: : : : {np(dat)} + {cp(że)}
straszno: archaiczny: : : : {np(dat)} + {prepnp(przed,inst)}
straszno: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,że)}
straszno: pewny: : : : {np(dat)} + {xp(locat)}
sucho: pewny: : : : {np(dat)} + {xp(caus)} + {xp(locat)}
super: pewny: : : : {comprepnp(pod względem)}
super: wątpliwy: : : : {comprepnp(w stosunku do)}
super: pewny: : : : {cp(gdy)}
super: potoczny: : : : {cp(jak)}
super: pewny: : : : {cp(jeśli)}
super: pewny: : : : {cp(kiedy)}
super: pewny: : : : {cp(że)}
super: pewny: : : : {infp(_)}
super: pewny: : : : {np(dat)} + {prepnp(w,loc)}
super: pewny: : : : {np(dat)} + {prepnp(z,inst)}
super: pewny: : : : {np(dat)} + {xp(locat)}
super: pewny: : : : {prepnp(dla,gen)}
super: pewny: : : : {xp(mod[advp(mod)])}
swojsko: pewny: : : : controller{np(dat)} + controllee{infp(_)}
swojsko: pewny: : : : {np(dat)} + {prepnp(z,inst)}
swojsko: pewny: : : : {np(dat)} + {xp(locat)}
sympatycznie: pewny: : pred: : controller{np(dat)} + controllee{infp(_)}
sympatycznie: pewny: : pred: : {np(dat)} + {cp(gdy)}
sympatycznie: potoczny: : pred: : {np(dat)} + {cp(jak)}
sympatycznie: pewny: : pred: : {np(dat)} + {cp(jeśli)}
sympatycznie: pewny: : pred: : {np(dat)} + {cp(kiedy)}
sympatycznie: pewny: : pred: : {np(dat)} + {cp(że)}
sympatycznie: pewny: : pred: : {np(dat)} + {xp(locat)}
szykownie: pewny: : : : {infp(_)}
szykownie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
szykownie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
ślicznie: pewny: : : : {cp(gdy)}
ślicznie: potoczny: : : : {cp(jak)}
ślicznie: pewny: : : : {cp(jeśli)}
ślicznie: pewny: : : : {cp(kiedy)}
ślicznie: pewny: : : : {cp(że)}
ślicznie: pewny: : : : {infp(_)}
ślicznie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
ślicznie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
ślicznie: pewny: : : : {xp(locat)}
śmiesznie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
śmiesznie: pewny: : : : {cp(gdy)}
śmiesznie: potoczny: : : : {cp(jak)}
śmiesznie: pewny: : : : {cp(jeśli)}
śmiesznie: pewny: : : : {cp(kiedy)}
śmiesznie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
śmiesznie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
śmiesznie: pewny: : : : {prepnp(dla,gen)}
śpieszno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
śpieszno: pewny: : : : {np(dat)} + {cp(żeby)}
śpieszno: pewny: : : : {np(dat)} + {prepnp(do,gen);prepncp(do,gen,żeby)}
śpieszno: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,żeby)}
śpieszno: pewny: : : : {np(dat)} + {xp(adl)}
świetnie: pewny: : : : {comprepnp(pod względem)}
świetnie: pewny: : : : {cp(gdy)}
świetnie: potoczny: : : : {cp(jak)}
świetnie: pewny: : : : {cp(jeśli)}
świetnie: pewny: : : : {cp(kiedy)}
świetnie: pewny: : : : {infp(_)}
świetnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
świetnie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
świetnie: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
świetnie: pewny: : : : {xp(mod[advp(mod)])}
tęskno: pewny: : : : {np(dat)} + {prepnp(do,gen);prepncp(do,gen,int);prepncp(do,gen,żeby)}
tęskno: pewny: : : : {np(dat)} + {prepnp(za,inst);prepncp(za,inst,int);prepncp(za,inst,że);prepncp(za,inst,żeby)}
trudno: pewny: : : : controller{np(dat)} + controllee{infp(_)}
trudno: pewny: : : : {cp(żeby)}
trudno: pewny: : : : {np(dat)} + {cp(że)}
twardo: pewny: : : : controller{np(dat)} + controllee{infp(_)}
twardo: pewny: : : : {np(dat)} + {prepnp(w,acc)}
twardo: pewny: : : : {np(dat)} + {prepnp(w,loc)}
twardo: pewny: : : : {np(dat)} + {xp(locat)}
uciesznie: pewny: : : : {infp(_)}
uciesznie: pewny: : : : {np(dat)} + {cp(gdy)}
uciesznie: pewny: : : : {np(dat)} + {cp(kiedy)}
wesoło: wątpliwy: : : : {np(dat)} + {comprepnp(za sprawą)}
wesoło: pewny: : : : {np(dat)} + {cp(gdy)}
wesoło: potoczny: : : : {np(dat)} + {cp(jak)}
wesoło: pewny: : : : {np(dat)} + {cp(jeśli)}
wesoło: pewny: : : : {np(dat)} + {cp(kiedy)}
wesoło: pewny: : : : {np(dat)} + {cp(że)}
wesoło: pewny: : : : {np(dat)} + {prepnp(z,inst)}
wesoło: pewny: : : : {np(dat)} + {xp(caus)}
wesoło: pewny: : : : {np(dat)} + {xp(locat)}
właściwie: pewny: : : : {comprepnp(pod względem)}
właściwie: pewny: : : : {xp(mod[advp(mod)])}
właściwie: pewny: : pred: : {infp(_)}
właśnie: pewny: : : : {cp(że)}
właśnie: pewny: : : : {cp(żeby)}
wspaniale: pewny: : : : controller{np(dat)} + controllee{infp(_)}
wspaniale: pewny: : : : {cp(gdy)}
wspaniale: potoczny: : : : {cp(jak)}
wspaniale: pewny: : : : {cp(jeśli)}
wspaniale: pewny: : : : {cp(kiedy)}
wspaniale: pewny: : : : {np(dat)} + {comprepnp(pod względem)}
wspaniale: pewny: : : : {np(dat)} + {cp(że)}
wspaniale: pewny: : : : {np(dat)} + {prepnp(z,inst)}
wspaniale: pewny: : : : {np(dat)} + {xp(locat)}
współcześnie: pewny: : : : {prepnp(do,gen)}
współcześnie: pewny: : : : {prepnp(z,inst)}
wygodnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
wygodnie: pewny: : : : {np(dat)} + {cp(gdy)}
wygodnie: potoczny: : : : {np(dat)} + {cp(jak)}
wygodnie: pewny: : : : {np(dat)} + {cp(jeśli)}
wygodnie: pewny: : : : {np(dat)} + {cp(kiedy)}
wygodnie: pewny: : : : {np(dat)} + {cp(że)}
wygodnie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
wygodnie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
wygodnie: pewny: : : : {np(dat)} + {xp(locat)}
wygodnie: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
wygodnie: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
wygodnie: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
wygodnie: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
wygodnie: pewny: : : : {prepnp(dla,gen)} + {cp(żeby)}
zabawnie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
zabawnie: pewny: : : : {cp(gdy)}
zabawnie: potoczny: : : : {cp(jak)}
zabawnie: pewny: : : : {cp(jeśli)}
zabawnie: pewny: : : : {cp(kiedy)}
zabawnie: pewny: : : : {cp(że)}
zabawnie: pewny: : : : {prepnp(dla,gen)}
zabawnie: pewny: : : : {xp(locat)}
zależnie: potoczny: : : : {cp(int)}
zależnie: pewny: : : : {prepnp(od,gen);prepncp(od,gen,int)}
zaszczytnie: pewny: : : : {infp(_)}
zaszczytnie: pewny: : : : {np(dat)}
zaszczytnie: pewny: : : : {prepnp(dla,gen)}
zdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
zdrowo: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
zdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
zdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
zdrowo: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
zdrowo: pewny: : : : {prepnp(dla,gen)} + {infp(_)}
zimno: pewny: : : : {np(dat)} + {prepnp(w,acc)} + {xp(caus)}
zimno: pewny: : : : {np(dat)} + {xp(locat)}
znakomicie: pewny: : : : {comprepnp(pod względem)}
znakomicie: pewny: : : : {cp(gdy)}
znakomicie: potoczny: : : : {cp(jak)}
znakomicie: pewny: : : : {cp(jeśli)}
znakomicie: pewny: : : : {cp(kiedy)}
znakomicie: pewny: : : : {cp(że)}
znakomicie: pewny: : : : {infp(_)}
znakomicie: pewny: : : : {np(dat)} + {prepnp(w,loc)}
znakomicie: pewny: : : : {np(dat)} + {prepnp(z,inst)}
znakomicie: pewny: : : : {prepnp(dla,gen)}
znakomicie: pewny: : : : {xp(mod[advp(mod)])}
znośnie: pewny: : : : {infp(_)}
znośnie: pewny: : : : {prepnp(dla,gen)}
zręcznie: pewny: : : : {comprepnp(pod względem)}
zręcznie: pewny: : : : controller{np(dat)} + controllee{infp(_)}
zręcznie: pewny: : : : {xp(mod[advp(mod)])}
zupełnie: pewny: : : : {compar(jak)}
zupełnie: pewny: : : : {cp(jakby)}
źle: pewny: : : : controller{np(dat)} + controllee{infp(_)}
źle: pewny: : : : {np(dat)} + {compar(jako)}
źle: pewny: : : : {np(dat)} + {comprepnp(od strony)}
źle: pewny: : : : {np(dat)} + {comprepnp(pod względem)}
źle: pewny: : : : {np(dat)} + {comprepnp(ze względu na)}
źle: pewny: : : : {np(dat)} + {cp(gdy)}
źle: potoczny: : : : {np(dat)} + {cp(jak)}
źle: pewny: : : : {np(dat)} + {cp(jeśli)}
źle: pewny: : : : {np(dat)} + {cp(kiedy)}
źle: pewny: : : : {np(dat)} + {cp(że)}
źle: pewny: : : : {np(dat)} + {prepnp(w,loc)}
źle: pewny: : : : {np(dat)} + {prepnp(z,inst);prepncp(z,inst,int);prepncp(z,inst,że)}
źle: pewny: : : : {np(dat)} + {xp(caus)}
źle: pewny: : : : {np(dat)} + {xp(locat)}
źle: pewny: : : : {prepnp(dla,gen)} + {cp(gdy)}
źle: potoczny: : : : {prepnp(dla,gen)} + {cp(jak)}
źle: pewny: : : : {prepnp(dla,gen)} + {cp(jeśli)}
źle: pewny: : : : {prepnp(dla,gen)} + {cp(kiedy)}
źle: pewny: : : : {prepnp(dla,gen)} + {cp(że)}
źle: pewny: : : : {prepnp(o,acc)}
żałośnie: pewny: : : : {infp(_)}
