src
stringlengths 721
1.04M
|
|---|
#!/usr/bin/env python
# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
from __future__ import with_statement
__license__ = 'GPL v3'
__copyright__ = '2009, Kovid Goyal <[email protected]>'
__docformat__ = 'restructuredtext en'
from PyQt4.Qt import Qt, QAbstractListModel, QVariant, SIGNAL
from calibre.gui2.convert.page_setup_ui import Ui_Form
from calibre.gui2.convert import Widget
from calibre.gui2 import NONE
from calibre.customize.ui import input_profiles, output_profiles
class ProfileModel(QAbstractListModel):
def __init__(self, profiles):
QAbstractListModel.__init__(self)
self.profiles = list(profiles)
def rowCount(self, *args):
return len(self.profiles)
def data(self, index, role):
profile = self.profiles[index.row()]
if role == Qt.DisplayRole:
return QVariant(profile.name)
if role in (Qt.ToolTipRole, Qt.StatusTipRole, Qt.WhatsThisRole):
w, h = profile.screen_size
if w >= 10000:
ss = _('unlimited')
else:
ss = _('%d x %d pixels') % (w, h)
ss = _('Screen size: %s') % ss
return QVariant('%s [%s]' % (profile.description, ss))
return NONE
class PageSetupWidget(Widget, Ui_Form):
TITLE = _('Page Setup')
COMMIT_NAME = 'page_setup'
def __init__(self, parent, get_option, get_help, db=None, book_id=None):
self.__connections = []
Widget.__init__(self, parent,
['margin_top', 'margin_left', 'margin_right', 'margin_bottom',
'input_profile', 'output_profile']
)
self.db, self.book_id = db, book_id
self.input_model = ProfileModel(input_profiles())
self.output_model = ProfileModel(output_profiles())
self.opt_input_profile.setModel(self.input_model)
self.opt_output_profile.setModel(self.output_model)
for g, slot in self.__connections:
g.selectionModel().currentChanged.connect(slot)
del self.__connections
for x in (self.opt_input_profile, self.opt_output_profile):
x.setMouseTracking(True)
self.connect(x, SIGNAL('entered(QModelIndex)'), self.show_desc)
self.initialize_options(get_option, get_help, db, book_id)
it = unicode(self.opt_input_profile.toolTip())
self.opt_input_profile.setToolTip('<p>'+it.replace('t.','t.\n<br>'))
it = unicode(self.opt_output_profile.toolTip())
self.opt_output_profile.setToolTip('<p>'+it.replace('t.','ce.\n<br>'))
def show_desc(self, index):
desc = index.model().data(index, Qt.StatusTipRole).toString()
self.profile_description.setText(desc)
def connect_gui_obj_handler(self, g, slot):
if g not in (self.opt_input_profile, self.opt_output_profile):
raise NotImplementedError()
self.__connections.append((g, slot))
def set_value_handler(self, g, val):
if g in (self.opt_input_profile, self.opt_output_profile):
g.clearSelection()
for idx, p in enumerate(g.model().profiles):
if p.short_name == val:
break
idx = g.model().index(idx)
sm = g.selectionModel()
g.setCurrentIndex(idx)
sm.select(idx, sm.SelectCurrent)
return True
return False
def get_value_handler(self, g):
if g in (self.opt_input_profile, self.opt_output_profile):
idx = g.currentIndex().row()
return g.model().profiles[idx].short_name
return Widget.get_value_handler(self, g)
|
# encoding: utf-8
"""
fragment.py
Created by Thomas Mangin on 2010-02-04.
Copyright (c) 2009-2015 Exa Networks. All rights reserved.
"""
# =================================================================== Fragment
# Uses bitmask operand format defined above.
# 0 1 2 3 4 5 6 7
# +---+---+---+---+---+---+---+---+
# | Reserved |LF |FF |IsF|DF |
# +---+---+---+---+---+---+---+---+
#
# Bitmask values:
# + Bit 7 - Don't fragment (DF)
# + Bit 6 - Is a fragment (IsF)
# + Bit 5 - First fragment (FF)
# + Bit 4 - Last fragment (LF)
class Fragment (int):
# reserved = 0xF0
LAST = 0x08
FIRST = 0x04
IS = 0x02
DONT = 0x01
def __str__ (self):
if self == 0x00: return 'not-a-fragment'
if self == self.DONT: return 'dont-fragment'
if self == self.IS: return 'is-fragment'
if self == self.FIRST: return 'first-fragment'
if self == self.LAST: return 'last-fragment'
return 'unknown fragment value %d' % int(self)
def NamedFragment (name):
fragment = name.lower()
if fragment == 'not-a-fragment': return Fragment(0x00)
if fragment == 'dont-fragment': return Fragment(Fragment.DONT)
if fragment == 'is-fragment': return Fragment(Fragment.IS)
if fragment == 'first-fragment': return Fragment(Fragment.FIRST)
if fragment == 'last-fragment': return Fragment(Fragment.LAST)
raise ValueError('unknown fragment name %s' % fragment)
|
'''
SASSIE: Copyright (C) 2011 Joseph E. Curtis, Ph.D.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
import os,sys,string,locale,bisect,random,time,platform
import numpy
import random
try:
import Gnuplot,Gnuplot.PlotItems, Gnuplot.funcutils
except:
pass
import sasmol.sasmol as sasmol
import sassie.simulate.constraints.constraints as constraints
import sassie.simulate.monomer_monte_carlo.dihedral_monte_carlo as dihedral
import sassie.simulate.monomer_monte_carlo.dihedral_rotate as dihedral_rotate
import sassie.simulate.energy.dihedral_energy as energy
import sassie.simulate.monomer_monte_carlo.pairs as pairs
import sassie.simulate.monomer_monte_carlo.step as step
import nmer_overlap_check
import nmer_nrotate
# NMER_DIHEDRAL
#
# 09/26/05 -- gag-dihedral search : jc
# 11/19/05 -- gag-dimer dihedral search : jc
# 06/29/09 -- generalized to nmer : jc/sr
# 11/17/11 -- added sasmol support : jc
#
#LC 1 2 3 4 5 6 7
#LC4567890123456789012345678901234567890123456789012345678901234567890123456789
# * **
'''
NMR_DIHEDRAL is the module that contains the functions
that are used to generate ensembles of structures by varying
protein dihedral angles. This particular version allows multiple
flexible proteins in the presence of non-flexible proteins and
nucleic acids.
This module is called from Protein Complex Dihedral Generation from
the main GUI through the graphical_complex_generate.py script.
This module calls to C / Python extension modules to speed up
calculations.
'''
def unpack_variables(variables):
runname = variables['runname'][0]
dcdfile = variables['dcdfile'][0]
path = variables['path'][0]
pdbfile = variables['pdbfile'][0]
trials = variables['trials'][0]
goback = variables['goback'][0]
temp = variables['temp'][0]
nsegments = variables['nsegments'][0]
segbasis = variables['segbasis'][0]
npsegments = variables['npsegments'][0]
flpsegname = variables['flpsegname'][0]
sseglow = variables['seglow'][0]
sseghigh = variables['seghigh'][0]
#cutoff = variables['cutoff'][0]
lowrg = variables['lowrg'][0]
highrg = variables['highrg'][0]
zflag = variables['zflag'][0]
zcutoff = variables['zcutoff'][0]
cflag = variables['cflag'][0]
confile = variables['confile'][0]
plotflag = variables['plotflag'][0]
directedmc = variables['directedmc'][0]
seed = variables['seed'][0]
return runname,dcdfile,path,pdbfile,trials,goback,temp,nsegments,segbasis,npsegments,flpsegname,sseglow,sseghigh,lowrg,highrg,zflag,zcutoff,cflag,confile,plotflag,directedmc,seed
def print_failure(message,txtOutput):
txtOutput.put("\n\n>>>> RUN FAILURE <<<<\n")
txtOutput.put(">>>> RUN FAILURE <<<<\n")
txtOutput.put(">>>> RUN FAILURE <<<<\n\n")
txtOutput.put(message)
return
def wait(sti=None, prompt='Plot will clear in 2 seconds ...\n'):
'''
WAIT is the function to prompt the user to clear a plot on a screen
'''
if sti is not None:
print sti
try:
if(platform.system() == "Linux"):
import curses
stdscr = curses.initscr()
stdscr.addstr('press a key to continue')
c = stdscr.getch()
curses.endwin()
except:
time.sleep(1)
def alignment_initialization(all_segment_mol,asegs,abasis,flexible_segments,seglow,seghigh):
all_flexible_align_mask = []
all_flexible_coor_sub_m1 = []
all_flexible_com_sub_m1 = []
all_flexible_sub_m2 = []
for i in xrange(len(flexible_segments)):
this_segment = flexible_segments[i]
idx = asegs.index(this_segment)
m1 = all_segment_mol[idx]
if(m1.moltype()[0] == 'protein'):
this_basis = 'CA'
elif(m1.moltype()[0] == 'rna' or m1.moltype()[0] == 'dna'):
this_basis = 'P'
else:
print 'NO ALIGNMENT BASIS ATOM DEFINED FOR SEGNAME'
sys.exit()
### TODO need to handle the exception in complex_filter.py
### ONLY protein and RNA need this alignment
# get alignment sub molecule
align_filter = 'name[i] == "'+this_basis+'" and (segname[i] == "'+this_segment+'") and (resid[i] >= '+str(seglow[i])+' and resid[i] <= '+str(seghigh[i])+')'
error,align_mask = m1.get_subset_mask(align_filter)
all_flexible_align_mask.append(align_mask)
sub_m1=sasmol.SasMol(2)
error = m1.copy_molecule_using_mask(sub_m1,align_mask,0)
com_sub_m1 = sub_m1.calccom(0)
sub_m1.center(0)
coor_sub_m1 = sub_m1.coor()[0]
all_flexible_coor_sub_m1.append(coor_sub_m1)
all_flexible_com_sub_m1.append(com_sub_m1)
sub_m2 = sasmol.SasMol(4)
error = m1.copy_molecule_using_mask(sub_m2,align_mask,0)
all_flexible_sub_m2.append(sub_m2)
return all_flexible_align_mask,all_flexible_coor_sub_m1,all_flexible_com_sub_m1,all_flexible_sub_m2
def run_file_utilities(runname,pdbpath,pdbfile,dcdfile):
direxist=os.path.exists(runname)
if(direxist==0):
os.system('mkdir -p '+runname+'/')
#
# global run administration
#
genpath=runname+'/complex_monte_carlo'
genpaths=genpath+'/'
direxist=os.path.exists(genpath)
if(direxist==0):
os.system('mkdir -p '+genpath)
cpst='cp '+pdbpath+'/'+pdbfile+' '+genpaths
os.system(cpst)
#
# write global run name, pdb, and dcd filenames to .last_sas
#
fileexist=os.path.exists('.last_sas')
if(fileexist==1):
os.system('mv -f .last_sas .last_sas_bu')
lastsasfile=open('./.last_sas','w')
lastsasfile.write('run_name\t'+runname+'\n')
lastsasfile.write('pdb_name\t'+pdbfile+'\n')
lastsasfile.write('dcd_name\t'+dcdfile+'\n')
return lastsasfile,genpaths
def process_input_variables(psegvariables,segbasis,sseglow,sseghigh,flpsegname):
allsith=[]
allsnumranges=[]
allsrlow=[]
allsrnum=[]
allmoltype=[]
for i in range(len(psegvariables)):
allsnumranges.append(psegvariables[i][0])
allsith.append(psegvariables[i][1])
allsrlow.append(psegvariables[i][2])
allsrnum.append(psegvariables[i][3])
allmoltype.append(psegvariables[i][4])
#abasis=string.split(segbasis,',')
abasis=[item.strip() for item in string.split(segbasis,',')]
#seglow=string.split(sseglow,',')
#seghigh=string.split(sseghigh,',')
aith=[] ; anumranges=[] ; arlow=[] ; arnum=[]; amoltype=[]
for i in range(len(allsith)):
linith=string.split(allsith[i],',')
locith=[]
for i in range(len(linith)):
tith=linith[i]
fith=locale.atof(tith)
if(fith>180.0):
fith=180.0
elif(fith<0.0):
fith=0.0
locith.append(fith)
aith.append(locith)
for i in range(len(allsnumranges)):
nr=locale.atoi(allsnumranges[i])
anumranges.append(nr)
for i in range(len(allsrlow)):
linrlow=string.split(allsrlow[i],',')
linrnum=string.split(allsrnum[i],',')
rlow=[] ; rnum=[]
for k in range(len(linrlow)):
trlow=locale.atoi(linrlow[k])
trnum=locale.atoi(linrnum[k])
rlow.append(trlow)
rnum.append(trnum)
#print 'rlow = ',rlow
#print 'rnum = ',rnum
arlow.append(rlow)
arnum.append(rnum)
for i in range(len(psegvariables)):
moltype=allmoltype[i].strip()
amoltype.append(moltype)
'''
print 'anumranges = ',anumranges
print 'aith = ',aith
print 'arlow = ',arlow
print 'arnum = ',arnum
'''
raw_flexible_segments = string.split(flpsegname,",")
flexible_segments = []
for fp in raw_flexible_segments:
flexible_segments.append(fp.strip())
#print 'flexible_segments = ',flexible_segments
return amoltype,allsith,allsnumranges,allsrlow,allsrnum,abasis,sseglow,sseghigh,anumranges,aith,arlow,arnum,flexible_segments
def initialize_segments(m1,flexible_segments,nsegments,abasis):
segname = m1.segname()
asegs=[]
for tseg in segname:
if(tseg not in asegs):
asegs.append(tseg)
numsegs=len(asegs)
print 'found ',numsegs,' segment names'
first_last_resid = []
all_segment_mask = []
all_segment_full_mask = []
all_segment_basis_full_mask = []
all_segment_mol = []
tmask = ''
keyword_basis = False
if(len(abasis) == 1):
basis = abasis[0].strip()
if(basis.lower() == 'all' or basis.lower() == 'heavy' or basis.lower() == 'backbone'):
keyword_basis = True
for i in xrange(numsegs):
segmol = sasmol.SasMol(0)
error,segment_full_mask = m1.get_subset_mask('segname[i] == "'+asegs[i]+'"')
m1.copy_molecule_using_mask(segmol,segment_full_mask,0)
this_resid = segmol.resid()
first_last_resid.append([this_resid[0],this_resid[-1]])
all_segment_full_mask.append(segment_full_mask)
all_segment_mol.append(segmol)
### this is where abasis is used --> and this is where it matters!
if keyword_basis:
if(basis.lower() == 'all'):
#print 'setting up all atom overlap arrays'
segmol.set_average_vdw()
npairs = segmol.natoms()*(segmol.natoms() - 1)/2
cutoff_array = numpy.zeros(npairs,numpy.float)
pairs.pairs(segmol.atom_vdw(),cutoff_array)
keyword_basis_filter = 'segname[i] == "'+asegs[i]+'" and (not name[i] == "None") '
elif(basis.lower() == 'backbone'):
this_moltype = segmol.moltype()[0]
#print 'this_moltype = ',this_moltype ### check this
if(segmol.moltype()[0] == 'protein'):
keyword_basis_filter = 'segname[i] == "'+asegs[i]+'" and (name[i] == "N" or name[i] == "CA" or name[i] == "C") '
elif(segmol.moltype()[0] == 'rna' or segmol.moltype()[0] == 'dna'):
keyword_basis_filter = 'segname[i] == "'+asegs[i]+'" and (name[i] == "P" or name[i] == "O5\'" or name[i] == "C5\'" or name[i] == "C4\'" or name[i] == "C3\'" or name[i] == "O3\'") '
else:
keyword_basis_filter = 'segname[i] == "'+asegs[i]+'" and (not name[i][0] == "H") '
### TODO --> add to complex_filter so the following hack is not needed
elif(basis.lower() == 'heavy'):
keyword_basis_filter = 'segname[i] == "'+asegs[i]+'" and (not name[i][0] == "H") '
error,segment_basis_mask = m1.get_subset_mask(keyword_basis_filter)
else:
error,segment_basis_mask = m1.get_subset_mask('segname[i] == "'+asegs[i]+'" and name[i] =="'+abasis[i].strip()+'"')
all_segment_basis_full_mask.append(segment_basis_mask)
error,segment_mask = all_segment_mol[i].get_subset_mask('segname[i] == "'+asegs[i]+'"')
all_segment_mask.append(segment_mask)
### TODO ... this is probably why flexible segments need to be first!!
### should just take the NAMES of the flexible segnames to make this
###
### this is also where abasis is used --> but basis_full_mask is ONLY used for zcut
### checking: abasis itself is passed to check_overlap in nmer_nrotate
###
### OPTIONS: use moltype()[0] for each asegs[i] to set the basis (CA--> protein, P --> RNA)
### or better yet, use not hydrogen instead ... as this is ONLY used for z-cut check
###
tmask += '(segname[i] == "'+asegs[i]+'" and (not name[i][0] == "H")) '
#tmask+='segname[i] == "'+asegs[i]+'" and name[i] =="'+abasis[i].strip()+'"'
if i!=len(flexible_segments)-1:
tmask+=' or '
error,basis_full_mask= m1.get_subset_mask(tmask)
#print 'first_last_resid = ',first_last_resid
return asegs,first_last_resid,all_segment_mask,all_segment_full_mask,all_segment_basis_full_mask,basis_full_mask,all_segment_mol,keyword_basis
def initialize_interaction_regions(m1,interpairs,npairs,cutoff,sseglow,asegs,abasis):
if(len(interpairs)>0):
print 'pair distances < cut == ',cutoff,' angstroms between segments have been found'
print 'these distances will be ignorned in overlap check'
print 'interpairs = ',interpairs
else:
print 'all distances between segments are greater than cut == ',cutoff
print 'normal overlap checking will be used'
print 'npairs = ',npairs
### initialize interaction regions in each segment ###
interres=[] ; interatom=[]
for i in range(len(interpairs)):
segnum_1 = interpairs[i][0][0]
segnum_2 = interpairs[i][0][1]
for j in range(len(interpairs[i][1])):
resnum_1 = interpairs[i][1][j][0]
resnum_2 = interpairs[i][1][j][1]
### TODO --> need to match basis here as well
### TODO --> need to match basis here as well
### TODO --> need to match basis here as well
basis_segment_1 = '(segname[i] == "'+asegs[segnum_1]+'" and name[i] =="'+abasis[segnum_1].strip()+'")'
error,basis_mask_segment_1 = m1.get_subset_mask(basis_segment_1)
#idx_1 = numpy.where(basis_mask_segment_1==1.0)[0][resnum_1] # a ugly numpy function
idx_1 = filter(lambda x:basis_mask_segment_1[x]==1.0, range(len(basis_mask_segment_1)))[resnum_1]
basis_segment_2 = '(segname[i] == "'+asegs[segnum_2]+'" and name[i] =="'+abasis[segnum_2].strip()+'")'
error,basis_mask_segment_2 = m1.get_subset_mask(basis_segment_2)
#idx_2 = numpy.where(basis_mask_segment_2==1.0)[0][resnum_2] # a ugly numpy function
idx_2 = filter(lambda x:basis_mask_segment_2[x]==1.0, range(len(basis_mask_segment_2)))[resnum_2]
interres.append([resnum_1,resnum_2])
interatom.append([idx_1,idx_2])
print 'interres = ',interres
print 'interatom = ',interatom
return interatom,interres
def set_up_dihedral_arrays(all_segment_mol,asegs,abasis,amoltype,first_last_resid,flexible_segments,anumranges,arlow,arnum,keyword_basis,txtOutput):
flexible_dihedral_parameters = []
all_flexible_basis_mask = []
for i in xrange(len(flexible_segments)):
this_segname = flexible_segments[i]
idx = asegs.index(this_segname)
m1=all_segment_mol[idx]
### TODO --> need to deal with specific basis here
### TODO --> need to deal with specific basis here
### TODO --> need to deal with specific basis here
if(keyword_basis):
if amoltype[i]=='protein':
basis_atom = "CA"
elif amoltype[i]=='rna':
#basis_atom = "P"
basis_atom = "O5\'"
basis_filter = 'name[i] == "'+basis_atom+'" and segname[i] == "'+this_segname+'"'
else:
basis_filter = 'name[i] == "'+abasis[idx]+'" and segname[i] == "'+this_segname+'"'
error,basis_mask = m1.get_subset_mask(basis_filter)
all_flexible_basis_mask.append(basis_mask)
basis_m1=sasmol.SasMol(1)
error = m1.copy_molecule_using_mask(basis_m1,basis_mask,0)
basis_resname = basis_m1.resname()
basis_resid = basis_m1.resid()
arespsi=[] ; aresphi=[]
numranges=anumranges[i] ; reslow=arlow[i] ; numcont=arnum[i]
if amoltype[i]=='protein':
respsi=[] ; resphi=[]
energy.protein_initialization(respsi,resphi,basis_resid,basis_resname,numranges,reslow,numcont,first_last_resid[idx],txtOutput)
flexible_dihedral_parameters.append([respsi,resphi])
elif amoltype[i]=='rna':
resalpha = [] ; resbeta = [] ; resgamma = [] ; resdelta = [] ; resepsilon = [] ; reseta = []
energy.rna_initialization(resalpha,resbeta,resgamma,resdelta,resepsilon,reseta,basis_resid,basis_resname,numranges,reslow,numcont,first_last_resid[idx],txtOutput)
flexible_dihedral_parameters.append([resalpha,resbeta,resgamma,resdelta,resepsilon,reseta])
return flexible_dihedral_parameters,all_flexible_basis_mask
def set_up_constraints(m1,cflag,confile):
if(cflag == 1):
filter_flag = 0
error,constraint_basis1_array, constraint_basis2_array,distance_array,type_array = constraints.read_constraints(m1,confile,filter_flag)
mask_a_array = [] ; mask_b_array = []
for i in xrange(len(distance_array)):
print constraint_basis1_array[i]
print constraint_basis2_array[i]
print distance_array[i]
print type_array[i]
error,local_mask_a_array = m1.get_subset_mask(constraint_basis1_array[i])
error,local_mask_b_array = m1.get_subset_mask(constraint_basis2_array[i])
mask_a_array.append(local_mask_a_array)
mask_b_array.append(local_mask_b_array)
else:
mask_a_array = [] ; mask_b_array = []
distance_array = [] ; type_array = []
return mask_a_array,mask_b_array,distance_array,type_array
def setup_flexible_residue_mask_arrays(m1,flexible_segments,anumranges,arlow,arnum,amoltype,txtOutput):
all_flexible_residues = []
all_flexible_residue_rotation_indices = []
all_flexible_residue_rotation_mask = []
for i in xrange(len(flexible_segments)):
numranges=anumranges[i] ; reslow=arlow[i] ; numcont=arnum[i]
flexible_residues = dihedral.get_flexible_residues(numranges,reslow,numcont)
all_flexible_residues.append(flexible_residues)
segment_filter = 'segname[i] == "'+flexible_segments[i]+'"'
error,segment_mask = m1.get_subset_mask(segment_filter)
#print 'segment_filter = ',segment_filter
#print 'error = ',error
segment_m1=sasmol.SasMol(98)
error = m1.copy_molecule_using_mask(segment_m1,segment_mask,0)
molecule_type = amoltype[i]
residue_rotation_indices,residue_rotation_mask = dihedral.get_rotation_indices(segment_m1,molecule_type,flexible_residues,txtOutput)
all_flexible_residue_rotation_indices.append(residue_rotation_indices)
all_flexible_residue_rotation_mask.append(residue_rotation_mask)
return all_flexible_residues,all_flexible_residue_rotation_indices,all_flexible_residue_rotation_mask
def evaluate_rg(rg_difference_list,directed_rg_list,accepted_rg_list,this_rg_difference,this_rg,accepted):
maximum_value = max(rg_difference_list)
if(maximum_value > this_rg_difference):
index = rg_difference_list.index(maximum_value)
rg_difference_list[index] = this_rg_difference
directed_rg_list[index] = this_rg
accepted_rg_list[index] = accepted
return
### main method ###
def dihedralgenerate(variables,psegvariables,txtOutput):
#amoltype=['protein','protein']
#amoltype=['rna','protein']
#amoltype=['protein']
#ttxt=time.ctime()
ttxt=time.asctime( time.gmtime( time.time() ) )
st=''.join(['=' for x in xrange(60)])
txtOutput.put("\n%s \n" %(st))
txtOutput.put("DATA FROM RUN: %s \n\n" %(ttxt))
# unpack variables
runname,dcdfile,path,pdbfile,trials,goback,temp,nsegments,segbasis,npsegments,flpsegname,sseglow,sseghigh,lowrg,highrg,zflag,zcutoff,cflag,confile,plotflag,directedmc,seed=unpack_variables(variables)
segbasis.strip()
# process variables
amoltype,allsith,allsnumranges,allsrlow,allsrnum,abasis,seglow,seghigh,anumranges,aith,arlow,arnum,flexible_segments = process_input_variables(psegvariables,segbasis,sseglow,sseghigh,flpsegname)
import pprint; fout = open('a.txt','w'); pprint.pprint(variables,fout); pprint.pprint(psegvariables,fout); pprint.pprint(segbasis,fout); pprint.pprint(seglow,fout); pprint.pprint(seghigh,fout); pprint.pprint(flpsegname,fout); fout.close()
# set up run file I/O
lastsasfile,genpaths = run_file_utilities(runname,path,pdbfile,dcdfile)
kb=1.380658E-23 # J/K
beta=1.0/(temp*kb)
m1 = sasmol.SasMol(0)
m1.read_pdb(path+pdbfile)
nf1=m1.number_of_frames()
#print 'nf1 = %d\n' % nf1
dcdoutfile = m1.open_dcd_write(genpaths+dcdfile)
# set up segment arrays
asegs,first_last_resid,all_segment_mask,all_segment_full_mask,all_segment_basis_full_mask,basis_full_mask,all_segment_mol,keyword_basis = initialize_segments(m1,flexible_segments,nsegments,abasis)
# set up constraints variables
mask_a_array,mask_b_array,distance_array,type_array = set_up_constraints(m1,cflag,confile)
# set up segment alignment coordinates and com arrays
all_flexible_align_mask,all_flexible_coor_sub_m1,all_flexible_com_sub_m1,all_flexible_sub_m2 = alignment_initialization(all_segment_mol,asegs,abasis,flexible_segments,seglow,seghigh)
if(keyword_basis):
if(segbasis.lower() == 'all'):
cutoff = 0.8
elif(segbasis.lower() == 'heavy' or segbasis.lower() == 'backbone'):
cutoff = 0.8
else:
cutoff = 2.0
print 'cutoff = ',cutoff
check_initial_interactions = False
if(check_initial_interactions):
# survey interaction between segments
interpairs,npairs=nmer_overlap_check.nmer_overlap_check(m1,path,pdbfile,cutoff,abasis,keyword_basis)
interatom,interres = initialize_interaction_regions(m1,interpairs,npairs,cutoff,sseglow,asegs,abasis)
else:
interpairs = [] ; npairs = 0
interatom = [] ; interres = []
# set up dihedral parameters for each flexible segment
flexible_dihedral_parameters,all_flexible_basis_mask = set_up_dihedral_arrays(all_segment_mol,asegs,abasis,amoltype,first_last_resid,flexible_segments,anumranges,arlow,arnum,keyword_basis,txtOutput)
if(segbasis.lower() == 'all' or segbasis.lower() == 'heavy' or segbasis.lower() == 'backbone'):
print 'segbasis = ',segbasis,' so I should stop for now\n'
#sys.exit()
else:
print 'segbasis = ',segbasis,' so I should continue\n'
# set up flexible residue rotation mask arrays
all_flexible_residues,all_flexible_residue_rotation_indices,all_flexible_residue_rotation_mask = setup_flexible_residue_mask_arrays(m1,flexible_segments,anumranges,arlow,arnum,amoltype,txtOutput)
step_parameters = step.Setup()
hrg=0.0 ; lowestrg=1000.0
an='psi'
accepted=0 ; over=0 ; badrg=0 ; badz=0 ; badc=0 ; nsteps=0 ; arg=0.0 ; trg=0.0
coor = m1.coor()
frame = 0
# MAIN LOOP
q0=1;th=1.0;seg=asegs[0]
pairdat=[an,q0,th,seg]
all_rg_tally=[] ; accepted_rg_tally=[]
phi_tally=[] ; aphi_tally=[]
psi_tally=[] ; apsi_tally=[]
atpsi_tally=[] ; atphi_tally=[] ; atphipsi_tally=[]
if(plotflag == 1):
graph = Gnuplot.Gnuplot(debug=1)
graph.clear()
graph('set title "Rg Results"')
graph.xlabel('Structure Number')
graph.ylabel('Rg (Angstrom^2)')
nonbondflag = 0
if(seed[0] == 1):
from numpy.random import RandomState
seed_object = RandomState(seed[1])
else:
seed_object = -1
failtally=0 ; acc=0 ; afile=''; accfile=[]
minx=[] ; miny=[] ; minz=[]
maxx=[] ; maxy=[] ; maxz=[]
if(directedmc > 0):
rg_difference_list = []
directed_rg_list = []
accepted_rg_list = []
rg_list_length = 10 ### hardwired
for i in range(trials):
if(seed[0] == 1):
ran_num = seed_object.rand()
tflexsegn = int(len(flexible_segments)*ran_num)
tsegn = asegs.index(flexible_segments[tflexsegn])
else:
tflexsegn = int(len(flexible_segments)*random.random())
tsegn = asegs.index(flexible_segments[tflexsegn])
tseg = asegs[tsegn]
molecule_type = amoltype[tflexsegn]
dtheta = aith[tflexsegn] ; numranges = anumranges[tflexsegn]
reslow = arlow[tflexsegn] ; numcont = arnum[tflexsegn]
segment_full_mask = all_segment_full_mask[tsegn]
error,new_coor = m1.get_coor_using_mask(frame,segment_full_mask)
segment_mol = all_segment_mol[tsegn]
segment_mol.setCoor(new_coor)
'''
if(i<10):
print 'segment_mol.coor()[0,0,0] = ',segment_mol.coor()[0,0,0]
else:
sys.exit()
'''
vdi,vdf,indices,this_mask=step_parameters.chooser(new_coor,segment_mol,pairdat,dtheta,numranges,reslow,numcont,flexible_dihedral_parameters[tflexsegn],beta,all_flexible_residue_rotation_indices[tflexsegn],all_flexible_residue_rotation_mask[tflexsegn],nonbondflag,first_last_resid[tsegn],molecule_type,seed_object)
'''
print 'len(indices) = ',len(indices)
print 'indices[0] = ',indices[0]
print 'indices[-1] = ',indices[-1]
print 'tsegn = ',tsegn
'''
pairdat[3] = tseg
an=pairdat[0] ; q0=pairdat[1] ; th=pairdat[2] ; seg=pairdat[3]
nsteps+=1
re=[0,0,0,0.0,0.0,lowestrg,hrg,0,0,[]]
newafile = nmer_nrotate.rotate(coor,m1,q0,th,an,cutoff,lowrg,highrg,re,accepted,zflag,zcutoff,cflag,dcdoutfile,indices,this_mask,all_flexible_basis_mask[tflexsegn],all_flexible_sub_m2[tflexsegn],all_flexible_align_mask[tflexsegn],all_flexible_coor_sub_m1[tflexsegn],all_flexible_com_sub_m1[tflexsegn],mask_a_array,mask_b_array,distance_array,type_array,first_last_resid[tsegn],molecule_type,all_segment_mask[tsegn],segment_full_mask,all_segment_basis_full_mask,basis_full_mask,all_segment_mol[tsegn],asegs,abasis,interatom,interres)
print '.', ; sys.stdout.flush()
accepted=accepted+re[0] ; over=over+re[1] ; badrg=badrg+re[2] ; rg_value=re[3]
trg=trg+re[3] ; arg=arg+re[4] ; lowestrg=re[5] ; hrg=re[6]
badz=badz+re[7] ; badc=badc+re[8]
if(len(re[9])>0):
minmax=re[9]
minx.append(minmax[0][0]) ; miny.append(minmax[0][1]) ; minz.append(minmax[0][2])
maxx.append(minmax[1][0]) ; maxy.append(minmax[1][1]) ; maxz.append(minmax[1][2])
all_rg_tally.append([i,rg_value])
if(re[0]==1):
accepted_rg_tally.append([i,accepted,rg_value])
if(directedmc > 0):
if(len(rg_difference_list)<= rg_list_length):
this_rg_difference = abs(rg_value - directedmc)
rg_difference_list.append(this_rg_difference)
directed_rg_list.append(rg_value)
accepted_rg_list.append(accepted)
else:
this_rg_difference = abs(rg_value - directedmc)
evaluate_rg(rg_difference_list,directed_rg_list,accepted_rg_list,this_rg_difference,rg_value,accepted)
if(re[0]==0):
if(failtally==goback):
failtally=0
if(accepted > 0):
if(seed[0] == 1):
ran_num = seed_object.rand()
dum=int(accepted*ran_num)-1
elif(directedmc > 0):
local_rg_list_length = len(directed_rg_list)
ran_num = random.randrange(0,local_rg_list_length)
dum = accepted_rg_list[ran_num]
else:
dum=int(accepted*random.random())-1
if(dum==-1):
print '\nreloading coordinates from original starting structure'
m1.read_pdb(path+pdbfile,fastread=True,saspdbrx_topology=True)
coor=m1.coor()
else:
print '\nreloading coordinates from a previously accepted structure'
m1.read_single_dcd_step(genpaths+dcdfile,dum+1)
#m1.read_single_dcd_step(genpaths+dcdfile,dum)
coor=m1.coor()
else:
print '\n>>>>>reloading coordinates from original starting structure'
m1.read_pdb(path+pdbfile,fastread=True,saspdbrx_topology=True)
coor=m1.coor()
else:
failtally=failtally+1
if(((i+1)%(float(trials)/100.0)==0 or (trials<10))):
fraction_done = (float(i+1)/float(trials))
progress_string='\nCOMPLETED '+str(i+1)+' of '+str(trials)+' : '+str(fraction_done*100.0)+' % done'
print('%s\n' % progress_string)
print accepted,' configurations accepted out of ',nsteps,(float(accepted)/nsteps)*100.0,' %\n\n'
report_string='STATUS\t'+str(fraction_done)
txtOutput.put(report_string)
if(i>9):
if((i+1)%(trials/10)==0 and accepted > 0 and i+1>10):
if(plotflag == 1):
graph.plot(Gnuplot.Data(all_rg_tally,using='1:2 w p ps 4',title='all Rg'),Gnuplot.Data(accepted_rg_tally,using='1:3 w lp pt 5 ps 2',title='accepted'))
fraction_done = (float(i+1)/float(trials))
report_string='STATUS\t'+str(fraction_done)
txtOutput.put(report_string)
elif(accepted > 0):
if(plotflag == 1):
graph.plot(Gnuplot.Data(all_rg_tally,using='1:2 w p ps 4',title='all Rg'),Gnuplot.Data(accepted_rg_tally,using='1:3 w lp pt 5 ps 2',title='accepted'))
fraction_done = (float(i+1)/float(trials))
report_string='STATUS\t'+str(fraction_done)
txtOutput.put(report_string)
m1.close_dcd_write(dcdoutfile)
rgplot=open('./'+runname+'/complex_monte_carlo/'+dcdfile+'.all_rg_results_data.txt','w')
rgplot.write('# structure number (structure 1 = 1; not 0), Rg (all)\n')
for ii in range(len(all_rg_tally)):
rgplot.write('%i\t%f\n' % (all_rg_tally[ii][0]+1,all_rg_tally[ii][1]))
rgplot.close()
rgplot=open('./'+runname+'/complex_monte_carlo/'+dcdfile+'.accepted_rg_results_data.txt','w')
rgplot.write('# structure number (structure 1 = 1; not 0), Rg (accepted)\n')
for ii in range(len(accepted_rg_tally)):
rgplot.write('%i\t%f\t%i\n' % (accepted_rg_tally[ii][1]-1,accepted_rg_tally[ii][2],accepted_rg_tally[ii][0]+1))
rgplot.close()
'''
outfile2=open(genpaths+dcdfile+'.phi','w')
outfile3=open(genpaths+dcdfile+'.psi','w')
outfile5=open(genpaths+dcdfile+'.aphi','w')
outfile6=open(genpaths+dcdfile+'.apsi','w')
outfile7=open(genpaths+dcdfile+'.aphivsapsi','w')
outfile7.write('# ACCEPTED STRUCTURES\n')
outfile7.write('# AA phi psi\n')
for i in range(len(phi_tally)):
outfile2.write('%i\t%f\n' % (phi_tally[i][0],phi_tally[i][1]))
for i in range(len(psi_tally)):
outfile3.write('%i\t%f\n' % (psi_tally[i][0],psi_tally[i][1]))
for i in range(len(aphi_tally)):
outfile5.write('%i\t%f\n' % (aphi_tally[i][0],aphi_tally[i][1]))
for i in range(len(apsi_tally)):
outfile6.write('%i\t%f\n' % (apsi_tally[i][0],apsi_tally[i][1]))
for i in range(len(atphipsi_tally)):
outfile7.write('%i\t%f\t%f\n' % (atphipsi_tally[i][0],atphipsi_tally[i][1],atphipsi_tally[i][2]))
outfile2.close()
outfile3.close()
outfile5.close()
outfile6.close()
outfile7.close()
'''
ttxt=time.ctime()
st=''.join(['=' for x in xrange(60)])
if(accepted > 0):
txtOutput.put("Average accepted rg2 = %lf\n" % (arg/(accepted)))
txtOutput.put("Configurations and statistics saved in %s directory\n" % ('./'+genpaths))
else:
txtOutput.put("Average accepted rg2 = %lf\n" % (0.0))
txtOutput.put("\n NO ACCEPTED MOVES\n\n Statistics saved in %s directory\n" % (genpaths))
outfile7=open(genpaths+dcdfile+'.stats','w')
outfile7.write('%s\t%f\t%s\t%f\n' % ('lowest Rg = ',lowestrg,'highest Rg = ',hrg))
outfile7.write('%s\t%i\t%s\t%i\t%s\t%f%s\n' % ('accepted ',accepted,' out of ',nsteps,' moves : ',(accepted/float(nsteps))*100.0, ' %'))
outfile7.write('%s\t%i\t%s\t%i\t%s\t%f%s\n' % ('overlapped ',over,' out of ',nsteps,' moves : ',(over/float(nsteps))*100.0, ' %'))
outfile7.write('%s\t%i\t%s\t%i\t%s\t%f%s\n' % ('bad rg2 ',badrg,' out of ',nsteps,' moves : ',(badrg/float(nsteps))*100.0, ' %'))
outfile7.write('%s\t%i\t%s\t%i\t%s\t%f%s\n' % ('bad z-filter ',badz,' out of ',nsteps,' moves : ',(badz/float(nsteps))*100.0, ' %'))
outfile7.write('%s\t%i\t%s\t%i\t%s\t%f%s\n' % ('bad constaints ',badc,' out of ',nsteps,' moves : ',(badc/float(nsteps))*100.0, ' %'))
if(accepted>0):
outfile7.write('%s\t%f\n' % ('average accepted rg2 = ',arg/(accepted)))
else:
outfile7.write('%s\t%f\n' % ('average accepted rg2 = ',0.0))
outfile7.write('%s\t%f\n' % ('average total rg2 of ensemble = ',trg/(nsteps)))
print '\n\nDCD data were written to %s\n' % ('./'+genpaths+dcdfile)
txtOutput.put( "\nDCD data were written to %s\n\n" % ('./'+genpaths+dcdfile))
txtOutput.put("lowest Rg = %lf\t highest Rg = %lf\n" % (lowestrg,hrg))
txtOutput.put("accepted %d out of %d : %lf percent\n" % (accepted,nsteps,(accepted/float(nsteps))*100.0))
txtOutput.put("overlapped %d out of %d moves : %lf percent\n" % (over,nsteps,(float(over)/float(nsteps))*100.0))
txtOutput.put("bad rg2 %d out of %d moves : %lf percent\n" % (badrg,nsteps,(float(badrg)/float(nsteps))*100.0))
if(zflag==1):
txtOutput.put("bad zcut %d out of %d moves : %lf percent\n\n\n" % (badz,nsteps,(float(badz)/float(nsteps))*100.0))
if(cflag==1):
txtOutput.put("constraint filter rejected %d out of %d moves : %lf percent\n\n\n" % (badc,nsteps,(float(badc)/float(nsteps))*100.0))
if(len(minx)>0 and len(miny)>0 and len(minz)>0 and len(maxx)>0 and len(maxy)>0 and len(maxz)>0):
min_x = numpy.min(minx) ; min_y = numpy.min(miny) ; min_z = numpy.min(minz)
max_x = numpy.max(maxx) ; max_y = numpy.max(maxy) ; max_z = numpy.max(maxz)
txtOutput.put("\nminimum x = %lf\t maximum x = %lf -> range: %lf Angstroms\n" % (min_x,max_x,(max_x-min_x)))
txtOutput.put("minimum y = %lf\t maximum y = %lf -> range: %lf Angstroms\n" % (min_y,max_y,(max_y-min_y)))
txtOutput.put("minimum z = %lf\t maximum z = %lf -> range: %lf Angstroms\n\n" % (min_z,max_z,(max_z-min_z)))
outfile7.write("\nminimum x = %lf\t maximum x = %lf -> range: %lf Angstroms\n" % (min_x,max_x,(max_x-min_x)))
outfile7.write("minimum y = %lf\t maximum y = %lf -> range: %lf Angstroms\n" % (min_y,max_y,(max_y-min_y)))
outfile7.write("minimum z = %lf\t maximum z = %lf -> range: %lf Angstroms\n\n" % (min_z,max_z,(max_z-min_z)))
outfile7.close()
else:
outfile7.close()
txtOutput.put("\n%s \n" %(st))
lastsasfile.close()
print 'COMPLEX DIHEDRAL IS DONE'
time.sleep(1.5)
if(plotflag == 1):
wait('\n')
return()
if __name__=='__main__':
runname = 'run_0'
dcdfile = 'run_0.dcd'
path = './'
pdbfile = 'fram601.pdb'
trials = '50'
goback = '50'
nsegments = '2'
npsegments = '2'
flpsegname = 'ENDA,ENDB'
segbasis = 'CA, CA'
#segbasis = 'all'
#segbasis = 'heavy'
#segbasis = 'backbone'
seglow = '95, 95'
seghigh = '110, 110'
temp = '300.0'
lowrg = '20.0'
highrg = '185.0'
zflag = '0'
zcutoff = '0.0'
cflag = '0'
confile = 'constraints.txt'
directedmc = '0'
psffilepath='./'
psffilename = 'refgag.psf'
import sassie.sasconfig as sasconfig
parmfilepath=sasconfig._bin_path+'toppar'
parmfilename = 'par_all27_prot_na.inp'
plotflag = '1'
seed = '0, 123'
svariables={}
svariables['cflag'] = (cflag,'int')
svariables['confile'] = (confile,'string')
svariables['dcdfile'] = (dcdfile,'string')
svariables['directedmc'] = (directedmc,'float')
svariables['flpsegname'] = (flpsegname, 'string')
svariables['goback'] = (goback,'int')
svariables['highrg'] = (highrg,'float')
svariables['lowrg'] = (lowrg,'float')
svariables['npsegments'] = (npsegments,'int')
svariables['nsegments'] = (nsegments,'int')
svariables['parmfilename'] = (parmfilename,'string')
svariables['path'] = (path,'string')
svariables['pdbfile'] = (pdbfile,'string')
svariables['plotflag'] = (plotflag,'int')
svariables['psffilename'] = (psffilename,'string')
svariables['runname'] = (runname,'string')
svariables['seed'] = (seed,'int_array')
svariables['segbasis'] = (segbasis,'string')
svariables['seghigh'] = (seghigh,'int_array')
svariables['seglow'] = (seglow,'int_array')
svariables['temp'] = (temp,'float')
svariables['trials'] = (trials,'int')
svariables['zcutoff'] = (zcutoff,'float')
svariables['zflag'] = (zflag, 'int')
psegvariables= [['1', '30', '2', '30', 'protein'], ['1', '30', '2', '30', 'protein']]
import sassie.interface.input_filter as input_filter
error,variables=input_filter.type_check_and_convert(svariables)
#error=generate_filter.check_protein(variables,eflag,monflag)
if(len(error)>0):
print 'error = ',error
sys.exit()
runname=variables['runname'][0]
import multiprocessing
txtQueue=multiprocessing.JoinableQueue()
dihedralgenerate(variables,psegvariables,txtQueue)
|
# coding: utf8
from __future__ import unicode_literals
LOOKUP = {
'berabad-abad': 'abad',
'keabadian': 'abadi',
'keabadiannya': 'abadi',
'mengabadi': 'abadi',
'mengabadikan': 'abadi',
'mengabadikannya': 'abadi',
'mengabadian': 'abadi',
'pengabadian': 'abadi',
'pengabadiannya': 'abadi',
'mengabahkan': 'abah',
'abaian': 'abai',
'terabai': 'abai',
'terabaikan': 'abai',
'terabaikannya': 'abai',
'pengabai': 'abai',
'pengabaikan': 'abai',
'pengabaian': 'abai',
'mengabaikan': 'abai',
'mengabaikannya': 'abai',
'mengabaikanku': 'abai',
'mengabaikanmu': 'abai',
'penabalan': 'tabal',
'menabalkan': 'tabal',
'berabang': 'abang',
'abaran': 'abar',
'terabar': 'abar',
'mengabar': 'abar',
'mengabarkan': 'abar',
'mengabarkannya': 'abar',
'mengabari': 'abar',
'mengabaran': 'abar',
'abar-abar': 'abar',
'berabarkan': 'abar',
'berabdas': 'abdas',
'pengabdi': 'abdi',
'pengabdinya': 'abdi',
'pengabdikan': 'abdi',
'pengabdian': 'abdi',
'mengabdi': 'abdi',
'mengabdinya': 'abdi',
'mengabdilah': 'abdi',
'mengabdikan': 'abdi',
'mengabdian': 'abdi',
'pengabdiannya': 'abdi',
'pengabdianlah': 'abdi',
'pengabdianku': 'abdi',
'pengabdianmu': 'abdi',
'mengaben': 'aben',
'mengabenkan': 'aben',
'pengabenan': 'aben',
'pengabenannya': 'aben',
'mengabet': 'abet',
'berabjad': 'abjad',
'mengabjad': 'abjad',
'mengabjadkan': 'abjad',
'pengabjadan': 'abjad',
'keabnormalan': 'abnormal',
'mengabolisikan': 'abolisi',
'berabonemen': 'abonemen',
'seabrek': 'abrek',
'abrit-abritan': 'abrit-abrit',
'keabsahan': 'absah',
'keabsahannya': 'absah',
'pengabsahan': 'absah',
'pengabsahannya': 'absah',
'mengabsahkan': 'absah',
'mengabsahkannya': 'absah',
'mengabsen': 'absen',
'mengabsenkan': 'absen',
'mengabsenkannya': 'absen',
'mengabsorb': 'absorb',
'mengabsorpsi': 'absorpsi',
'keabstainan': 'abstain',
'mengabstrakkan': 'abstrak',
'mengabu': 'abu',
'mengabukan': 'abuk',
'mengabukannya': 'abu',
'perabuan': 'abu',
'mengabui': 'abu',
'pengabuan': 'abu',
'memperabukan': 'abu',
'keabu-abuan': 'abu-abu',
'abuhan': 'abuh',
'abuh-abuhan': 'abuh',
'mengabuk': 'abuk',
'mengabukkan': 'abuk',
'mengabur': 'kabur',
'mengaburkan': 'kabur',
'mengaburkannya': 'kabur',
'pengabur': 'abur',
'pengaburkan': 'abur',
'pengaburan': 'abur',
'mengacah': 'acah',
'pengacah': 'acah',
'beracah-acah': 'acah',
'mengacak': 'kacak',
'mengacaknya': 'kacak',
'acak-acak': 'acak',
'acak-acakkan': 'acak',
'acak-acakan': 'acak',
'acak-acakannya': 'acak',
'mengacan': 'acan',
'mengacapi': 'acap',
'acap-acap': 'acap',
'mengacapkan': 'acap',
'beracara': 'acara',
'beracaranya': 'acara',
'mengacara': 'acara',
'mengacarakan': 'acara',
'pengacara': 'acara',
'pengacaranya': 'acara',
'pengacaralah': 'acara',
'pengacaraku': 'acara',
'kepengacaraan': 'acara',
'acatan': 'acat',
'mengacau': 'kacau',
'mengacaukan': 'kacau',
'mengacaukannya': 'kacau',
'mengaci': 'aci',
'mengacikan': 'aci',
'aci-acian': 'aci-aci',
'aci-acinya': 'aci-aci',
'mengaci-acikan': 'aci-aci',
'acoan': 'aco',
'mengaco': 'aco',
'aco-acoan': 'aco',
'acuan': 'acu',
'acuannya': 'acu',
'acuanku': 'acu',
'acuanmu': 'acu',
'mengacu': 'acu',
'mengacunya': 'acu',
'mengacukan': 'acu',
'pengacuan': 'acu',
'mengacu-acu': 'acu',
'acuhan': 'acuh',
'mengacuhkan': 'acuh',
'mengacuhkannya': 'acuh',
'mengacuhkanku': 'acuh',
'acuman': 'acum',
'pengacum': 'acum',
'mengacum': 'acum',
'mengacung': 'acung',
'mengacungkan': 'acung',
'mengacungkannya': 'acung',
'mengacungi': 'acung',
'adanya': 'ada',
'adanyanya': 'ada',
'adanyalah': 'ada',
'berada': 'ada',
'beradanya': 'ada',
'beradalah': 'ada',
'beradai': 'ada',
'beradaan': 'ada',
'pengada': 'ada',
'pengadakan': 'ada',
'pengadaan': 'ada',
'keadaan': 'ada',
'keadaannya': 'ada',
'keadaanlah': 'ada',
'keadaanku': 'ada',
'keadaanmu': 'ada',
'seadanya': 'ada',
'seadanyalah': 'ada',
'pengadaannya': 'ada',
'berada-ada': 'ada',
'ada-adanya': 'ada',
'keberadaan': 'ada',
'keberadaannya': 'ada',
'keberadaanku': 'ada',
'keberadaanmu': 'ada',
'mengadakan': 'ada',
'mengadakannya': 'ada',
'mengada-ada': 'ada',
'mengada-adalah': 'ada',
'mengada-adakan': 'ada',
'ada-ada saja': 'ada',
'ada-adanyakah': 'ada',
'beradab': 'adab',
'beradabnya': 'adab',
'beradaban': 'adab',
'keadaban': 'adab',
'keadabannya': 'adab',
'mengadabi': 'adab',
'peradaban': 'adab',
'peradabannya': 'adab',
'memperadabkan': 'adab',
'adakalanya': 'adakala',
'diadang': 'adang',
'diadangnya': 'adang',
'mengadang': 'kadang',
'mengadangnya': 'kadang',
'mengadangkan': 'kadang',
'pengadang': 'adang',
'pengadangnya': 'adang',
'pengadangan': 'adang',
'mengadangi': 'adang',
'adang-adang': 'adang',
'mengadang-adangi': 'adang',
'adap-adapan': 'adap',
'beradaptasi': 'adaptasi',
'beradaptasinya': 'adaptasi',
'beradaptasilah': 'adaptasi',
'pengadaptasian': 'adaptasi',
'mengadaptasikan': 'adaptasi',
'mengadaptasikannya': 'adaptasi',
'mengadar': 'kadar',
'mengadari': 'kadar',
'beradat': 'adat',
'teradat': 'adat',
'mengadat': 'adat',
'mengadatkan': 'adat',
'beradegan': 'adegan',
'pengadeganan': 'adegan',
'beradeh': 'adeh',
'mengadem': 'adem',
'mengademkan': 'adem',
'beradik': 'adik',
'beradiknya': 'adik',
'beradiki': 'adik',
'memperadik': 'adik',
'adik-beradik': 'adik',
'beradik-berkakak': 'adik',
'keadikuasaan': 'adikuasa',
'teradil': 'adil',
'keadilan': 'adil',
'keadilannya': 'adil',
'keadilanlah': 'adil',
'keadilan-mu': 'adil',
'pengadil': 'adil',
'pengadilnya': 'adil',
'pengadilkan': 'adil',
'pengadili': 'adil',
'pengadilan': 'adil',
'teradili': 'adil',
'mengadili': 'adil',
'mengadilinya': 'adil',
'mengadilikan': 'adil',
'peradilan': 'adil',
'peradilannya': 'adil',
'peradilanlah': 'adil',
'peradilankan': 'adil',
'pengadilannya': 'adil',
'pengadilanlah': 'adil',
'pengadilani': 'adil',
'pengadilanan': 'adil',
'berkeadilan': 'adil',
'berkeadilannya': 'adil',
'berkeadilanlah': 'adil',
'mengadon': 'adon',
'adonan': 'adon',
'adonannya': 'adon',
'pengadopsi': 'adopsi',
'pengadopsinya': 'adopsi',
'pengadopsian': 'adopsi',
'mengadopsi': 'adopsi',
'mengadopsinya': 'adopsi',
'mengadopsikan': 'adopsi',
'pengadopsiannya': 'adopsi',
'mengadreskan': 'adres',
'teradu domba': 'adu domba',
'mengadu domba': 'adu domba',
'pengadu domba': 'adu domba',
'pengadudombaan': 'adu domba',
'mengadudombakan': 'adu domba',
'memperadudombakan': 'adu domba',
'aduan': 'adu',
'aduannya': 'adu',
'aduanlah': 'adu',
'beradu': 'radu',
'beradunya': 'radu',
'beradulah': 'radu',
'beradukan': 'radu',
'pengadu': 'adu',
'pengadunya': 'adu',
'pengadukan': 'aduk',
'pengadukannya': 'aduk',
'pengaduan': 'adu',
'mengadu': 'adu',
'mengadunya': 'adu',
'mengadulah': 'adu',
'mengadukan': 'aduk',
'mengadukannya': 'adu',
'mengaduan': 'adu',
'peraduan': 'radu',
'peraduannya': 'radu',
'peraduanmu': 'radu',
'pengaduannya': 'adu',
'mengadukankan': 'adu',
'memperadukan': 'adu',
'pengadu untung': 'adu untung',
'mengadu untung': 'adu untung',
'teraduh': 'aduh',
'mengaduh': 'aduh',
'adukan': 'aduk',
'adukannya': 'aduk',
'teraduk': 'aduk',
'mengaduk': 'aduk',
'mengaduknya': 'aduk',
'mengadukkan': 'aduk',
'pengaduk': 'aduk',
'pengaduknya': 'aduk',
'aduk-adukan': 'aduk',
'mengaduk-aduk': 'aduk',
'mengaduk-aduknya': 'aduk',
'adunan': 'adun',
'beradun': 'adun',
'pengadun': 'adun',
'pengadunan': 'adun',
'mengadunkan': 'adun',
'beraerobatik': 'aerobatik',
'mengafiatkan': 'afiat',
'berafiliasi': 'afiliasi',
'berafiliasinya': 'afiliasi',
'beraga': 'raga',
'beragai': 'raga',
'keagaan': 'aga',
'mengagakan': 'aga',
'beragah': 'agah',
'mengagah': 'agah',
'mengagahi': 'agah',
'beragah-agah': 'agah',
'seagak': 'agak',
'diagak': 'agak',
'diagakan': 'agak',
'teragak': 'agak',
'agaknya': 'agak',
'agak-agak': 'agak',
'seagak-agak': 'agak',
'mengagakkan': 'agak',
'beragak-agak': 'agak',
'mengagak-agak': 'agak',
'mengagak-agihkan': 'agak-agih',
'beragam': 'ragam',
'beragamnya': 'ragam',
'beragamlah': 'ragam',
'beragaman': 'ragam',
'beragama': 'agama',
'beragamanya': 'agama',
'beragamalah': 'agama',
'beragamakan': 'agama',
'beragamai': 'agama',
'beragamaan': 'agama',
'keagamaan': 'agama',
'keagamaannya': 'agama',
'keagamaannyalah': 'agama',
'keberagamaan': 'agama',
'keberagamaannya': 'agama',
'mengagamakan': 'agama',
'beragan': 'agan',
'mengagan': 'agan',
'mengagani': 'agan',
'mengagas': 'agas',
'mengagaskan': 'agas',
'keagenan': 'agen',
'keagenannya': 'agen',
'mengageni': 'agen',
'mengagendakan': 'agenda',
'mengagendakannya': 'agenda',
'beragih': 'agih',
'peragih': 'agih',
'mengagih': 'agih',
'pengagihan': 'agih',
'mengagihkan': 'agih',
'beragitasi': 'agitasi',
'mengagitasi': 'agitasi',
'beragogo': 'agogo',
'mengagresi': 'agresi',
'keagresifan': 'agresif',
'keagresifannya': 'agresif',
'keagresifanku': 'agresif',
'mengagulkan': 'agul',
'agunan': 'agun',
'agunannya': 'agun',
'agunanmu': 'agun',
'mengagunkan': 'agun',
'keagungan': 'agung',
'keagungannya': 'agung',
'mengagungkan': 'agung',
'mengagungkannya': 'agung',
'beragustusan': 'agustus',
'mengagut-agut': 'agut',
'mengahadkan': 'ahad',
'keahlian': 'ahli',
'keahliannya': 'ahli',
'keahlianku': 'ahli',
'keahlianmu': 'ahli',
'mengahlikan': 'ahli',
'berkeahlian': 'ahli',
'keahlinegaraan': 'ahli negara',
'keaiban': 'aib',
'mengaibkan': 'aib',
'berair': 'air',
'berairan': 'air',
'keairan': 'air',
'perairan': 'air',
'perairannya': 'air',
'perairani': 'air',
'perairanan': 'air',
'mengairi': 'air',
'mengairinya': 'air',
'pengairan': 'air',
'pengairannya': 'air',
'berpengairan': 'air',
'keajaiban': 'ajaib',
'keajaibannya': 'ajaib',
'keajaibanlah': 'ajaib',
'keajaibanku': 'ajaib',
'keajaiban-mu': 'ajaib',
'mengajaibkan': 'ajaib',
'ajakan': 'ajak',
'ajakannya': 'ajak',
'ajakanlah': 'ajak',
'ajakanku': 'ajak',
'ajakanmu': 'ajak',
'mengajak': 'ajak',
'mengajaknya': 'ajak',
'mengajakkan': 'ajak',
'mengajakan': 'ajak',
'mengajakku': 'ajak',
'mengajakmu': 'ajak',
'ajaran': 'ajar',
'ajarannya': 'ajar',
'ajaranku': 'ajar',
'ajaran-ku': 'ajar',
'belajar': 'ajar',
'belajarnya': 'ajar',
'belajarlah': 'ajar',
'belajarkan': 'ajar',
'belajari': 'ajar',
'belajarmu': 'ajar',
'pelajar': 'ajar',
'pelajarnya': 'ajar',
'pelajari': 'ajar',
'pelajaran': 'ajar',
'mengajar': 'ajar',
'mengajarnya': 'ajar',
'mengajarkan': 'ajar',
'mengajarkannya': 'ajar',
'mengajari': 'ajar',
'mengajaran': 'ajar',
'mengajarku': 'ajar',
'mengajarmu': 'ajar',
'pengajar': 'ajar',
'pengajarnya': 'ajar',
'pengajaran': 'ajar',
'pelajarannya': 'ajar',
'pelajaranlah': 'ajar',
'pelajaranmu': 'ajar',
'mengajarinya': 'ajar',
'mengajariku': 'ajar',
'mengajarimu': 'ajar',
'pembelajar': 'ajar',
'pembelajarnya': 'ajar',
'pembelajaran': 'ajar',
'pengajarannya': 'ajar',
'terpelajar': 'ajar',
'mempelajari': 'ajar',
'mempelajarinya': 'ajar',
'pemelajaran': 'ajar',
'mengajarkankan': 'ajar',
'mengajarkanku': 'ajar',
'mengajarkanmu': 'ajar',
'pembelajarannya': 'ajar',
'pembelajaranku': 'ajar',
'berpelajaran': 'ajar',
'membelajarkan': 'ajar',
'keterpelajaran': 'ajar',
'keterpelajarannya': 'ajar',
'berajojing': 'ajojing',
'ajuan': 'aju',
'ajuannya': 'aju',
'pengajuan': 'aju',
'pengajuannya': 'aju',
'pengajuanmu': 'aju',
'mengajukan': 'aju',
'mengajukannya': 'aju',
'diajuk': 'ajuk',
'diajukkan': 'ajuk',
'diajukkannya': 'ajuk',
'diajukan': 'ajuk',
'keajukan': 'ajuk',
'mengajuk': 'ajuk',
'mengajukkan': 'ajuk',
'mengajukkannya': 'ajuk',
'diajun': 'ajun',
'terajun': 'ajun',
'mengajun': 'ajun',
'mengajunkan': 'ajun',
'berakad': 'akad',
'berakal': 'akal',
'berakali': 'akal',
'mengakali': 'akal',
'mengakalinya': 'akal',
'akal-akal': 'akal',
'akal-akalnya': 'akal',
'akal-akalan': 'akal',
'seakal-akal': 'akal',
'seakal budi': 'akal',
'mengakalkan': 'akal',
'akanan': 'akan',
'berakan': 'akan',
'keakanan': 'akan',
'mengakan': 'akan',
'berseakan': 'akan',
'akan-akan': 'akan',
'keseakanan': 'akan',
'seakan-akan': 'akan',
'mengakankan': 'akan',
'berakar': 'akar',
'berakarnya': 'akar',
'berakarkan': 'akar',
'mengakar': 'akar',
'mengakarnya': 'akar',
'mengakarkan': 'akar',
'mengakari': 'akar',
'perakaran': 'akar',
'perakarannya': 'akar',
'akar-akaran': 'akar',
'keakasan': 'akas',
'akhiran': 'akhir',
'akhirannya': 'akhir',
'berakhir': 'akhir',
'berakhirnya': 'akhir',
'berakhirlah': 'akhir',
'berakhirkan': 'akhir',
'berakhiri': 'akhir',
'berakhiran': 'akhir',
'terakhir': 'akhir',
'terakhirnya': 'akhir',
'terakhirlah': 'akhir',
'terakhirkan': 'akhir',
'terakhiri': 'akhir',
'terakhirnyalah': 'akhir',
'terakhirku': 'akhir',
'terakhirmu': 'akhir',
'akhirnya': 'akhir',
'akhirnyanya': 'akhir',
'akhirnyalah': 'akhir',
'mengakhiri': 'akhir',
'mengakhirinya': 'akhir',
'mengakhirii': 'akhir',
'pengakhiran': 'akhir',
'mengakhirkan': 'akhir',
'akhir-akhirnya': 'akhir',
'aki-aki': 'aki',
'berakibat': 'akibat',
'berakibatnya': 'akibat',
'berakibatkan': 'akibat',
'berakibatan': 'akibat',
'akibatnya': 'akibat',
'akibatnyanya': 'akibat',
'mengakibatkan': 'akibat',
'mengakibatkannya': 'akibat',
'mengakibatkani': 'akibat',
'berakikah': 'akikah',
'mengakikahkan': 'akikah',
'mengakomodasi': 'akomodasi',
'mengakomodasinya': 'akomodasi',
'mengakomodasikan': 'akomodasi',
'mengakomodasikannya': 'akomodasi',
'keakraban': 'akrab',
'keakrabannya': 'akrab',
'keakrabanlah': 'akrab',
'mengakrabi': 'akrab',
'mengakrabinya': 'akrab',
'mengakrabkan': 'akrab',
'mengakrabkankan': 'akrab',
'berakrobat': 'akrobat',
'pengakroniman': 'akronim',
'mengakronimkan': 'akronim',
'beraksara': 'aksara',
'keberaksaraan': 'aksara',
'mengaksentuasi': 'aksentuasi',
'mengaksentuasikan': 'aksentuasi',
'mengaksep': 'aksep',
'mengakses': 'akses',
'mengaksesnya': 'akses',
'mengakseskan': 'akses',
'mengaksesi': 'akses',
'beraksi': 'aksi',
'beraksinya': 'aksi',
'beraksilah': 'aksi',
'pengaktif': 'aktif',
'pengaktifkan': 'aktif',
'pengaktifkannya': 'aktif',
'pengaktifan': 'aktif',
'keaktifan': 'aktif',
'keaktifannya': 'aktif',
'keaktifanku': 'aktif',
'keaktifanmu': 'aktif',
'pengaktifannya': 'aktif',
'mengaktifkan': 'aktif',
'mengaktifkannya': 'aktif',
'aktinisme': 'aktinik',
'pengaktualan': 'aktual',
'mengaktualkan': 'aktual',
'mengaktualkannya': 'aktual',
'mengaktualisasi': 'aktualisasi',
'mengaktualisasikan': 'aktualisasi',
'mengaktualisasikannya': 'aktualisasi',
'akuan': 'aku',
'beraku': 'aku',
'berakunya': 'aku',
'keakuan': 'aku',
'keakuannya': 'aku',
'mengaku': 'aku',
'mengakunya': 'aku',
'mengakulah': 'aku',
'mengakukan': 'aku',
'mengakui': 'aku',
'mengakuan': 'aku',
'mengakuku': 'aku',
'pengaku': 'aku',
'pengakukan': 'aku',
'pengakui': 'aku',
'pengakuan': 'aku',
'mengakuinya': 'aku',
'mengakuii': 'aku',
'mengakuiku': 'aku',
'pengakuannya': 'aku',
'pengakuanku': 'aku',
'beraku-akuan': 'aku',
'pengakuisisi': 'akuisisi',
'pengakuisisian': 'akuisisi',
'mengakuisisi': 'akuisisi',
'mengakuisisinya': 'akuisisi',
'terakuk': 'akuk',
'berakumulasi': 'akumulasi',
'terakumulasi': 'akumulasi',
'terakumulasinya': 'akumulasi',
'mengakumulasi': 'akumulasi',
'mengakumulasinya': 'akumulasi',
'mengakumulasikan': 'akumulasi',
'mengakumulasikannya': 'akumulasi',
'perakunan': 'akun',
'perakuntanan': 'akuntan',
'keakuran': 'akur',
'mengakuri': 'akur',
'mengakurkan': 'akur',
'keakuratan': 'akurat',
'keakuratannya': 'akurat',
'terala': 'ala',
'teralai': 'ala',
'alahan': 'alah',
'beralah': 'alah',
'kealahan': 'alah',
'mengalah': 'kalah',
'mengalahnya': 'kalah',
'mengalahlah': 'kalah',
'mengalahkan': 'kalah',
'mengalahkannya': 'kalah',
'mengalahi': 'kalah',
'mengalahan': 'kalah',
'peralahan': 'alah',
'teralahkan': 'alah',
'pengalahan': 'alah',
'mengalahkankan': 'kalah',
'mengalahkanku': 'kalah',
'mengalahkanmu': 'kalah',
'alah-mengalahi': 'alah',
'sealak-alak': 'alak',
'beralam': 'alam',
'beralaman': 'alam',
'kealaman': 'alam',
'mengalami': 'alam',
'mengalaminya': 'alam',
'mengalamilah': 'alam',
'mengalamii': 'alam',
'pengalaman': 'alam',
'pengalamannya': 'alam',
'pengalamanlah': 'alam',
'pengalamankan': 'alam',
'pengalamanan': 'alam',
'pengalamanku': 'alam',
'pengalamanmu': 'alam',
'berpengalaman': 'alam',
'berpengalamannya': 'alam',
'berpengalamanlah': 'alam',
'berpengalamanan': 'alam',
'beralamat': 'alamat',
'beralamatkan': 'alamat',
'mengalamati': 'alamat',
'mengalamatkan': 'alamat',
'mengalamatkannya': 'alamat',
'alangan': 'alang',
'teralang': 'alang',
'beralang': 'alang',
'pengalang': 'alang',
'pengalangan': 'alang',
'mengalang': 'alang',
'mengalangi': 'alang',
'beralangan': 'alang',
'mengalanginya': 'alang',
'mengalangkan': 'alang',
'alang-alangan': 'alang',
'teralang-alang': 'alang',
'mengalang-alangi': 'alang',
'mengalap': 'alap',
'dialas': 'alas',
'dialaskan': 'alas',
'dialasi': 'alas',
'dialasan': 'alas',
'alasan': 'alas',
'alasannya': 'alas',
'alasanlah': 'alas',
'alasanku': 'alas',
'alasanmu': 'alas',
'beralas': 'alas',
'beralaskan': 'alas',
'beralasan': 'alas',
'mengalas': 'alas',
'mengalasi': 'alas',
'beralasannya': 'alas',
'beralasanlah': 'alas',
'beralasankan': 'alas',
'pengalasan': 'alas',
'mengalaskan': 'alas',
'beralat': 'alat',
'beralatan': 'alat',
'mengalati': 'alat',
'peralatan': 'alat',
'peralatannya': 'alat',
'peralatanlah': 'alat',
'peralatanan': 'alat',
'memperalat': 'alat',
'memperalatnya': 'alat',
'memperalati': 'alat',
'mengalatkan': 'alat',
'memperalatkan': 'alat',
'aleman': 'alem',
'mengali': 'ali',
'mengalikan': 'kali',
'mengalikannya': 'kali',
'pengali-ali': 'ali-ali',
'mengali-ali': 'ali-ali',
'beraliansi': 'aliansi',
'teralienasi': 'alienasi',
'teralienasinya': 'alienasi',
'alif-alifan': 'alif',
'pengalihaksara': 'alih aksara',
'pengalihaksaraan': 'alih aksara',
'mengalihaksarakan': 'alih aksara',
'pengalih bahasa': 'alih bahasa',
'pengalihbahasaan': 'alih bahasa',
'mengalihbahasakan': 'alih bahasa',
'beralih fungsi': 'alih fungsi',
'teralih': 'alih',
'teralihnya': 'alih',
'teralihkan': 'alih',
'teralihkannya': 'alih',
'beralih': 'alih',
'beralihnya': 'alih',
'beralihlah': 'alih',
'beralihkan': 'alih',
'beralihan': 'alih',
'mengalih': 'alih',
'mengalihkan': 'alih',
'mengalihkannya': 'alih',
'mengalihan': 'alih',
'peralihan': 'alih',
'peralihannya': 'alih',
'alih-alih': 'alih',
'pengalihan': 'alih',
'pengalihannya': 'alih',
'pengalihanlah': 'alih',
'mengalihkanmu': 'alih',
'beralih tugas': 'alih tugas',
'pengalihtugasan': 'alih tugas',
'mengalihtugaskan': 'alih tugas',
'kealiman': 'alim',
'kealimannya': 'alim',
'mengalin': 'alin',
'mengalinkan': 'alin',
'alingan': 'aling',
'mengalingi': 'aling',
'aling-aling': 'aling',
'aling-alingan': 'aling',
'alip-alipan': 'alip',
'aliran': 'alir',
'alirannya': 'alir',
'alirani': 'alir',
'mengalir': 'alir',
'mengalirnya': 'alir',
'mengalirlah': 'alir',
'mengalirkan': 'alir',
'mengalirkannya': 'alir',
'mengaliri': 'alir',
'mengaliran': 'alir',
'mengalirinya': 'alir',
'pengaliran': 'alir',
'pengalirannya': 'alir',
'mengalit': 'alit',
'kealkalian': 'alkali',
'pengalkoholan': 'alkohol',
'alkoholometer': 'alkoholisme',
'ke-allah-an': 'allah',
'pengalokasian': 'alokasi',
'pengalokasiannya': 'alokasi',
'mengalokasikan': 'alokasi',
'mengalokasikannya': 'alokasi',
'alon-alon': 'alon',
'teralpa': 'alpa',
'kealpaan': 'alpa',
'kealpaannya': 'alpa',
'mengalpakan': 'alpa',
'beralu-aluan': 'alu',
'mengalum': 'alum',
'alunan': 'alun',
'alunannya': 'alun',
'beralun': 'alun',
'beralunkan': 'alun',
'beralunan': 'alun',
'teralun': 'alun',
'mengalun': 'alun',
'mengalunlah': 'alun',
'mengalunkan': 'alun',
'beralun-alun': 'alun',
'mengalup': 'alup',
'aluran': 'alur',
'beralur': 'alur',
'alur-aluran': 'alur',
'mengalur-alur': 'alur',
'mengamkan': 'am',
'mengamkankan': 'am',
'amai-amai': 'amai',
'amalan': 'amal',
'amalannya': 'amal',
'amalanmu': 'amal',
'beramal': 'amal',
'pengamal': 'amal',
'pengamalan': 'amal',
'pengamalannya': 'amal',
'mengamalkan': 'amal',
'mengamalkannya': 'amal',
'pengamalgam': 'amalgam',
'pengamalgaman': 'amalgam',
'keamanan': 'aman',
'keamanannya': 'aman',
'keamananlah': 'aman',
'keamananan': 'aman',
'keamananku': 'aman',
'keamananmu': 'aman',
'pengaman': 'aman',
'pengamannya': 'aman',
'pengamankan': 'aman',
'pengamanan': 'aman',
'pengamanku': 'aman',
'pengamanmu': 'aman',
'pengamanannya': 'aman',
'pengamananan': 'aman',
'memperaman': 'aman',
'mengamankan': 'aman',
'mengamankannya': 'aman',
'mengamankankan': 'aman',
'pengamanah': 'amanah',
'mengamanahkan': 'amanah',
'mengamanahkannya': 'amanah',
'beramanat': 'amanat',
'mengamanati': 'amanat',
'pengamanatan': 'amanat',
'mengamanatkan': 'amanat',
'mengamanatkannya': 'amanat',
'mengamang': 'amang',
'mengamangkan': 'amang',
'mengamangi': 'amang',
'mengamang-amang': 'amang',
'amaran': 'amar',
'amarannya': 'amar',
'mengamarkan': 'amar',
'amatan': 'amat',
'amatannya': 'amat',
'teramat': 'amat',
'teramati': 'amat',
'pengamat': 'amat',
'pengamatnya': 'amat',
'pengamatan': 'amat',
'mengamati': 'amat',
'mengamatinya': 'amat',
'mengamatiku': 'amat',
'memperamat': 'amat',
'pengamatannya': 'amat',
'memperamatkan': 'amat',
'mengamat-amati': 'amat',
'memperamat-amat': 'amat',
'memperamat-amatkan': 'amat',
'amatir-amatiran': 'amatir',
'ambaian': 'ambai',
'mengambai': 'ambai',
'mengambaikan': 'ambai',
'berambai-ambai': 'ambai',
'mengambai-ambaikan': 'ambai',
'diambak': 'ambak',
'mengambak': 'ambak',
'ambalan': 'ambal',
'ambalannya': 'ambal',
'mengambal': 'ambal',
'mengambali': 'ambal',
'berambal-ambalan': 'ambal',
'terambang': 'ambang',
'mengambang': 'kambang',
'mengambangnya': 'kambang',
'mengambangkan': 'kambang',
'mengambangkannya': 'kambang',
'mengambangi': 'kambang',
'mengambangan': 'kambang',
'terambang-ambang': 'ambang',
'mengambang-ambang': 'ambang',
'terambau': 'ambau',
'berambau': 'ambau',
'mengambau': 'ambau',
'ambekan': 'ambek',
'mengambek': 'ambek',
'pengambekparamaartaan': 'ambek paramaarta',
'mengambekparamaartakan': 'ambek paramaarta',
'mengambil alih': 'ambil alih',
'pengambilalihan': 'ambil alih',
'pengambilalihannya': 'ambil alih',
'ambilan': 'ambil',
'terambil': 'ambil',
'mengambil': 'ambil',
'mengambilnya': 'ambil',
'mengambilkan': 'ambil',
'mengambilkannya': 'ambil',
'mengambili': 'ambil',
'mengambilan': 'ambil',
'mengambilku': 'ambil',
'mengambilmu': 'ambil',
'pengambil': 'ambil',
'pengambilnya': 'ambil',
'pengambilkan': 'ambil',
'pengambilan': 'ambil',
'pengambilannya': 'ambil',
'berambil-ambil': 'ambil',
'ambil-mengambil': 'ambil',
'ambinan': 'ambin',
'mengambin': 'ambin',
'berambin': 'ambin',
'berambisi': 'ambisi',
'berambisinya': 'ambisi',
'ambring-ambringan': 'ambring',
'keambrukan': 'ambruk',
'keambrukannya': 'ambruk',
'pengambrukan': 'ambruk',
'mengambrukkan': 'ambruk',
'mengambul': 'ambul',
'mengambulkan': 'ambul',
'mengambung': 'ambung',
'mengambungkan': 'ambung',
'terambung-ambung': 'ambung',
'mengambung-ambung': 'ambung',
'mengambung-ambungkan': 'ambung',
'mengambur': 'ambur',
'mengamburkan': 'ambur',
'pengamen': 'amen',
'pengamennya': 'amen',
'mengamen': 'amen',
'mengamennya': 'amen',
'mengamenku': 'amen',
'mengamenmu': 'amen',
'mengamini': 'amin',
'mengamininya': 'amin',
'mengaminkan': 'amin',
'pengamitan': 'amit',
'pengamorfan': 'amorf',
'mengamortisasi': 'amortisasi',
'ampaian': 'ampai',
'berampai': 'ampai',
'terampai': 'ampai',
'mengampai': 'ampai',
'mengampaikan': 'ampai',
'mengampelas': 'ampelas',
'pengampelas': 'ampelas',
'pengampelasan': 'ampelas',
'mengampelasi': 'ampelas',
'mengamplopi': 'amplop',
'mengamplopkan': 'amplop',
'amprung-amprungan': 'amprung',
'pengampu': 'ampu',
'pengampunya': 'ampu',
'pengampuan': 'ampu',
'mengampu': 'ampu',
'mengampunya': 'ampu',
'mengampukan': 'ampu',
'keampuhan': 'ampuh',
'keampuhannya': 'ampuh',
'mengampuh': 'ampuh',
'pengampuh': 'ampuh',
'mengampuhkan': 'ampuh',
'mengampul': 'ampul',
'mengampulkan': 'ampul',
'ampuni': 'ampun',
'ampunilah': 'ampun',
'ampunan': 'ampun',
'ampunannya': 'ampun',
'ampunan-mu': 'ampun',
'keampunan': 'ampun',
'terampuni': 'ampun',
'pengampun': 'ampun',
'pengampunan': 'ampun',
'mengampuni': 'ampun',
'mengampuninya': 'ampun',
'mengampuniku': 'ampun',
'mengampunimu': 'ampun',
'pengampunannya': 'ampun',
'pengampunanlah': 'ampun',
'pengampunanmu': 'ampun',
'mengampunkan': 'ampun',
'amputan': 'amput',
'mengamput': 'amput',
'teramputasi': 'amputasi',
'mengamputasi': 'amputasi',
'mengamputasinya': 'amputasi',
'pengamputasian': 'amputasi',
'amukan': 'amuk',
'amukannya': 'amuk',
'beramuk': 'amuk',
'mengamuk': 'amuk',
'mengamuknya': 'amuk',
'mengamuklah': 'amuk',
'mengamuki': 'amuk',
'pengamuk': 'amuk',
'pengamukan': 'amuk',
'mengamukkan': 'amuk',
'beramuk-amuk': 'amuk',
'beramuk-amukan': 'amuk',
'teramung': 'amung',
'amung-amung': 'amung',
'penganakemasan': 'anak emas',
'menganakemaskan': 'anak emas',
'menganakemaskannya': 'anak emas',
'anakan': 'anak',
'anakannya': 'anak',
'beranak': 'anak',
'beranaknya': 'anak',
'anak-anak': 'anak',
'anak-anaknya': 'anak',
'anak-anaklah': 'anak',
'anak-anaki': 'anak',
'anak-anaknyalah': 'anak',
'anak-anakku': 'anak',
'anak-anakmu': 'anak',
'peranakan': 'anak',
'peranakannya': 'anak',
'anak-anakan': 'anak',
'anak-beranak': 'anak',
'memperanakkan': 'anak',
'menganak semang': 'anak semang',
'menganak sungai': 'anak sungai',
'penganaktirian': 'anak tiri',
'menganaktirikan': 'anak tiri',
'menganaktirikannya': 'anak tiri',
'penganalisis': 'analisis',
'menganalisis': 'analisis',
'menganalisisnya': 'analisis',
'menganalisisi': 'analisis',
'penganalisisan': 'analisis',
'menganalogikan': 'analogi',
'menganalogikannya': 'analogi',
'mengancaikan': 'ancai',
'mengancai-ancaikan': 'ancai',
'mengancak-ancak': 'ancak-ancak',
'ancaman': 'ancam',
'ancamannya': 'ancam',
'ancamanlah': 'ancam',
'ancamanan': 'ancam',
'ancamanmu': 'ancam',
'terancam': 'ancam',
'terancamnya': 'ancam',
'terancamkan': 'ancam',
'terancaman': 'ancam',
'mengancam': 'ancam',
'mengancamnya': 'ancam',
'mengancamkan': 'ancam',
'mengancaman': 'ancam',
'mengancamku': 'ancam',
'pengancam': 'ancam',
'pengancamnya': 'ancam',
'pengancaman': 'ancam',
'pengancamannya': 'ancam',
'ancang ekstrinsik': 'ancang',
'mengancar-ancar': 'ancar-ancar',
'mengancuk': 'ancuk',
'andaikan': 'andai',
'seandainya': 'andai',
'pengandaian': 'andai',
'pengandaiannya': 'andai',
'mengandaikan': 'andai',
'berandai-andai': 'andai',
'berandai-andailah': 'andai',
'pengandak': 'andak',
'mengandak': 'andak',
'mengandakan': 'andak',
'mengandakkan': 'andak',
'andalan': 'andal',
'andalannya': 'andal',
'andalanan': 'andal',
'andalanku': 'andal',
'terandal': 'andal',
'terandalkan': 'andal',
'keandalan': 'andal',
'keandalannya': 'andal',
'mengandalkan': 'andal',
'mengandalkannya': 'andal',
'mengandalkanku': 'andal',
'mengandalkanmu': 'andal',
'keterandalan': 'andal',
'keterandalannya': 'andal',
'andaman': 'andam',
'berandam': 'andam',
'terandam': 'andam',
'terandamnya': 'andam',
'mengandam': 'andam',
'pengandam': 'andam',
'mengandamkan': 'andam',
'mengandarkan': 'kandar',
'anduhan': 'anduh',
'teranduh': 'anduh',
'menganduh': 'anduh',
'penganduh': 'anduh',
'menganduhkan': 'anduh',
'keanehan': 'aneh',
'keanehannya': 'aneh',
'aneh-aneh': 'aneh',
'aneh-anehnya': 'aneh',
'aneh-anehlah': 'aneh',
'menganehkan': 'aneh',
'beraneh-aneh': 'aneh',
'menganekajeniskan': 'aneka jenis',
'beraneka': 'aneka',
'keanekaan': 'aneka',
'penganekaan': 'aneka',
'menganekakan': 'aneka',
'beraneka ragam': 'aneka ragam',
'keanekaragaman': 'aneka ragam',
'keanekaragamannya': 'aneka ragam',
'penganekaragaman': 'aneka ragam',
'menganekaragamkan': 'aneka ragam',
'menganeksasi': 'aneksasi',
'menganeksasinya': 'aneksasi',
'menganeksasikan': 'aneksasi',
'terangah': 'angah',
'mengangan': 'angan',
'mengangankan': 'angan',
'mengangani': 'angan',
'angan-angan': 'angan',
'angan-angannya': 'angan',
'angan-angankan': 'angan',
'angan-anganmu': 'angan',
'berangan-angan': 'angan',
'mengangan-angan': 'angan',
'mengangan-angankan': 'angan',
'berangga': 'rangga',
'beranggakan': 'rangga',
'beranggaan': 'rangga',
'menganggali': 'anggal',
'menganggalkan': 'anggal',
'anggapan': 'anggap',
'anggapannya': 'anggap',
'anggapanku': 'anggap',
'menganggap': 'anggap',
'menganggapnya': 'anggap',
'menganggapkan': 'anggap',
'menganggapi': 'anggap',
'menganggapan': 'anggap',
'menganggapku': 'anggap',
'menganggapmu': 'anggap',
'beranggapan': 'anggap',
'beranggap-anggapan': 'anggap',
'anggaran': 'anggar',
'anggarannya': 'anggar',
'anggaranlah': 'anggar',
'anggarankan': 'anggar',
'anggarani': 'anggar',
'anggaranku': 'anggar',
'peanggar': 'anggar',
'peanggaran': 'anggar',
'beranggar': 'anggar',
'beranggarkan': 'anggar',
'beranggaran': 'anggar',
'menganggar': 'anggar',
'menganggarkan': 'anggar',
'menganggarkannya': 'anggar',
'menganggaran': 'anggar',
'penganggaran': 'anggar',
'penganggarannya': 'anggar',
'anggar-anggar': 'anggar',
'teranggar-anggar': 'anggar',
'anggitan': 'anggit',
'anggitannya': 'anggit',
'menganggit': 'anggit',
'mengangglap': 'angglap',
'pengangglapan': 'angglap',
'beranggota': 'anggota',
'beranggotakan': 'anggota',
'beranggotaan': 'anggota',
'keanggotaan': 'anggota',
'keanggotaannya': 'anggota',
'penganggrekan': 'anggrek',
'menganggrekkan': 'anggrek',
'anggukan': 'angguk',
'anggukannya': 'angguk',
'berangguk': 'angguk',
'pengangguk': 'angguk',
'mengangguk': 'angguk',
'mengangguklah': 'angguk',
'menganggukkan': 'angguk',
'menganggukan': 'angguk',
'berangguk-angguk': 'angguk',
'terangguk-angguk': 'angguk',
'mengangguk-angguk': 'angguk',
'mengangguk-anggukkan': 'angguk',
'mengangguk-anggukan': 'angguk',
'beranggul': 'anggul',
'menganggul': 'anggul',
'teranggul-anggul': 'anggul',
'keanggunan': 'anggun',
'keanggunannya': 'anggun',
'menganggung': 'anggung',
'menganggungkan': 'anggung',
'anggung gaya': 'anggung',
'angguran': 'anggur',
'penganggur': 'anggur',
'pengangguran': 'anggur',
'menganggur': 'anggur',
'menganggurnya': 'anggur',
'menganggurkan': 'anggur',
'penganggurannya': 'anggur',
'pengangguranlah': 'anggur',
'beranggut': 'anggut',
'menganggut': 'anggut',
'menganggut-anggut': 'anggut',
'seangin': 'angin',
'terangin': 'angin',
'berangin': 'angin',
'mengangin': 'angin',
'keanginan': 'angin',
'mengangini': 'angin',
'peranginan': 'angin',
'angin-angin': 'angin',
'angin-anginnya': 'angin',
'angin-anginkan': 'angin',
'angin-anginan': 'angin',
'menganginkan': 'angin',
'angin-anginannya': 'angin',
'memperanginkan': 'angin',
'terangin-angin': 'angin',
'berangin-angin': 'angin',
'mengangin-anginkan': 'angin',
'mengangin-anginkannya': 'angin',
'mengangka': 'angka',
'mengangkai': 'angka',
'perangkaan': 'angka',
'pengangkaan': 'angka',
'mengangkakan': 'angka',
'berangka-angka': 'angka',
'berangka-angkaan': 'angka',
'keangkaraan': 'angkara',
'mengangkasa': 'angkasa',
'mengangkasanya': 'angkasa',
'angkatan': 'angkat',
'angkatannya': 'angkat',
'perangkat': 'angkat',
'perangkatnya': 'angkat',
'perangkatkan': 'angkat',
'perangkatan': 'angkat',
'perangkatmu': 'angkat',
'terangkat': 'angkat',
'terangkatnya': 'angkat',
'terangkatlah': 'angkat',
'seangkatan': 'angkat',
'seangkatannya': 'angkat',
'seangkatanmu': 'angkat',
'mengangkat': 'angkat',
'mengangkatnya': 'angkat',
'mengangkatkan': 'angkat',
'mengangkati': 'angkat',
'mengangkatan': 'angkat',
'mengangkatku': 'angkat',
'mengangkatmu': 'angkat',
'pengangkat': 'angkat',
'pengangkatnya': 'angkat',
'pengangkatan': 'angkat',
'seperangkat': 'perangkat',
'pengangkatannya': 'angkat',
'pengangkatanku': 'angkat',
'seperangkatan': 'angkat',
'mengangkat-angkat': 'angkat',
'mengangkat-angkatnya': 'angkat',
'mengangkit': 'angkit',
'angkringan': 'angkring',
'angkringannya': 'angkring',
'keangkuhan': 'angkuh',
'keangkuhannya': 'angkuh',
'mengangkup': 'angkup',
'angkup-angkup': 'angkup',
'terangkup-angkup': 'angkup',
'angkutan': 'angkut',
'angkutannya': 'angkut',
'angkutanlah': 'angkut',
'angkutanku': 'angkut',
'mengangkut': 'angkut',
'mengangkutnya': 'angkut',
'mengangkutkan': 'angkut',
'mengangkuti': 'angkut',
'pengangkut': 'angkut',
'pengangkutnya': 'angkut',
'pengangkutan': 'angkut',
'mengangkutinya': 'angkut',
'pengangkutannya': 'angkut',
'menganglap': 'anglap',
'menganglong': 'anglong',
'angonan': 'angon',
'mengangon': 'angon',
'pengangon': 'angon',
'pengangonan': 'angon',
'mengangop': 'angop',
'mengangsu': 'angsu',
'angsuran': 'angsur',
'angsurannya': 'angsur',
'angsuranku': 'angsur',
'berangsur': 'angsur',
'mengangsur': 'angsur',
'mengangsurnya': 'angsur',
'mengangsurkan': 'angsur',
'pengangsuran': 'angsur',
'mengangut': 'angut',
'anian': 'ani',
'mengani': 'ani',
'teraniaya': 'aniaya',
'teraniayanya': 'aniaya',
'menganiaya': 'aniaya',
'menganiayanya': 'aniaya',
'menganiayai': 'aniaya',
'menganiayaan': 'aniaya',
'menganiayaku': 'aniaya',
'penganiaya': 'aniaya',
'penganiayanya': 'aniaya',
'penganiayaan': 'aniaya',
'penganiayaannya': 'aniaya',
'teranja-anja': 'anja',
'beranja-anja': 'anja',
'dianjak': 'anjak',
'beranjak': 'anjak',
'beranjaknya': 'anjak',
'beranjaklah': 'anjak',
'menganjak': 'anjak',
'keberanjakan': 'anjak',
'keanjalan': 'anjal',
'menganjal': 'anjal',
'beranjang': 'anjang',
'beranjangkarya': 'anjangkarya',
'beranjangsana': 'anjangsana',
'peranjingan': 'anjing',
'menganju': 'anju',
'menganjukan': 'anju',
'anjungan': 'anjung',
'anjungannya': 'anjung',
'beranjung': 'anjung',
'menganjung': 'anjung',
'anjung-anjung': 'anjung',
'menganjungkan': 'anjung',
'anjung-anjungan': 'anjung',
'menganjung-anjung': 'anjung',
'menganjung-anjungkan': 'anjung',
'anjuran': 'anjur',
'anjurannya': 'anjur',
'beranjur': 'anjur',
'teranjur': 'anjur',
'penganjur': 'anjur',
'penganjurnya': 'anjur',
'penganjuran': 'anjur',
'menganjur': 'anjur',
'menganjurkan': 'anjur',
'menganjurkannya': 'anjur',
'menganjuran': 'anjur',
'menganjuri': 'anjur',
'menganjurian': 'anjur',
'menganjurkanmu': 'anjur',
'mengantamir': 'antamir',
'mengantapkan': 'antap',
'antaran': 'antar',
'antarannya': 'antar',
'antarani': 'antar',
'terantar': 'antar',
'berantar': 'antar',
'mengantar': 'antar',
'mengantarnya': 'antar',
'mengantarkan': 'antar',
'mengantarkannya': 'antar',
'mengantari': 'antar',
'mengantaran': 'antar',
'mengantarku': 'antar',
'mengantarmu': 'antar',
'pengantar': 'antar',
'pengantarnya': 'antar',
'pengantarkan': 'antar',
'pengantaran': 'antar',
'pengantarannya': 'antar',
'mengantarkankan': 'antar',
'mengantarkanku': 'antar',
'mengantarkanmu': 'antar',
'antar-mengantar': 'antar',
'perantara': 'antara',
'perantaranya': 'antara',
'perantaraan': 'antara',
'berantara': 'antara',
'berantarakan': 'antara',
'berantarakannya': 'antara',
'mengantara': 'antara',
'mengantaranya': 'antara',
'mengantarakan': 'antara',
'mengantarai': 'antara',
'pengantara': 'antara',
'pengantaranya': 'antara',
'pengantaraan': 'antara',
'memperantarai': 'antara',
'berantem': 'antem',
'berantemnya': 'antem',
'berantemlah': 'antem',
'beranteman': 'antem',
'mengantepi': 'antep',
'seantero': 'antero',
'mengantih': 'antih',
'pengantihan': 'antih',
'keantikan': 'antik',
'keantikannya': 'antik',
'mengantikkan': 'antik',
'menganting': 'anting',
'mengantingi': 'anting',
'anting-anting': 'anting',
'anting-antingnya': 'anting',
'anting-antingan': 'anting',
'berantisipasi': 'antisipasi',
'mengantisipasi': 'antisipasi',
'mengantisipasinya': 'antisipasi',
'mengantisipasikan': 'antisipasi',
'antrean': 'antre',
'antreannya': 'antre',
'antreanku': 'antre',
'pengantre': 'antre',
'pengantrean': 'antre',
'mengantre': 'antre',
'mengantrenya': 'antre',
'mengantrekan': 'antre',
'mengantrei': 'antre',
'berantuk': 'antuk',
'terantuk': 'antuk',
'mengantuk': 'kantuk',
'mengantuknya': 'kantuk',
'mengantukkan': 'kantuk',
'berantukan': 'antuk',
'mengantul': 'antul',
'berantun': 'antun',
'menganugerahi': 'anugerah',
'menganugerahinya': 'anugerah',
'penganugerahan': 'anugerah',
'penganugerahannya': 'anugerah',
'menganugerahkan': 'anugerah',
'menganugerahkannya': 'anugerah',
'menganulir': 'anulir',
'menganulirnya': 'anulir',
'menganulirkan': 'anulir',
'anutan': 'anut',
'anutannya': 'anut',
'penganut': 'anut',
'penganutnya': 'anut',
'penganutan': 'anut',
'menganut': 'anut',
'menganutnya': 'anut',
'menganuti': 'anut',
'anyaman': 'anyam',
'anyamannya': 'anyam',
'anyamanan': 'anyam',
'menganyam': 'anyam',
'menganyamnya': 'anyam',
'anyam-menganyam': 'anyam',
'menganyang': 'anyang',
'menganyang hati': 'anyang',
'teranyar': 'anyar',
'teranyarnya': 'anyar',
'teranyarmu': 'anyar',
'apaan': 'apa',
'mengapa': 'apa',
'mengapanya': 'apa',
'mengapalah': 'apa',
'mengapakan': 'apa',
'mengapakannya': 'apa',
'mengapai': 'apa',
'apa-apa': 'apa',
'apa-apanya': 'apa',
'apa-apalah': 'apa',
'apa-apakan': 'apa',
'apa-apaan': 'apa',
'apa-apanyalah': 'apa',
'mengapainya': 'apa',
'mengapaikan': 'apa',
'mengapa-apai': 'apa',
'dipengapakan': 'apa',
'mengapam': 'apam',
'pengapartemenan': 'apartemen',
'berapi': 'api',
'berapinya': 'api',
'mengapi': 'api',
'perapian': 'api',
'perapiannya': 'api',
'perapianku': 'api',
'berapi-api': 'api',
'berapi-apinya': 'api',
'memperapikan': 'api',
'mengapi-apikan': 'api',
'mengapikkan': 'apik',
'apitan': 'apit',
'berapit': 'apit',
'pengapit': 'kapit',
'pengapitnya': 'kapit',
'mengapit': 'apit',
'mengapitnya': 'apit',
'mengapitkan': 'apit',
'mengapiti': 'apit',
'pengapitan': 'apit',
'memperapitkan': 'apit',
'apkiran': 'apkir',
'apkirannya': 'apkir',
'mengapkir': 'apkir',
'mengaplikasikan': 'aplikasi',
'mengaplikasikannya': 'aplikasi',
'aplusan': 'aplus',
'aplusannya': 'aplus',
'mengaplus': 'aplus',
'perapotekan': 'apotek',
'berapresiasi': 'apresiasi',
'mengapresiasi': 'apresiasi',
'mengapresiasinya': 'apresiasi',
'mengapresiasikan': 'apresiasi',
'mengapresiasikannya': 'apresiasi',
'mengaprit': 'aprit',
'aprit-apritan': 'aprit',
'terapung': 'apung',
'terapungnya': 'apung',
'mengapung': 'apung',
'mengapungnya': 'apung',
'mengapunglah': 'apung',
'mengapungkan': 'apung',
'berapungan': 'apung',
'apung-apung': 'apung',
'terapung-apung': 'apung',
'berapung-apung': 'apung',
'mengarabkan': 'arab',
'kearab-araban': 'arab',
'searah': 'arah',
'searahnya': 'arah',
'arahan': 'arah',
'arahannya': 'arah',
'berarah': 'arah',
'terarah': 'arah',
'terarahnya': 'arah',
'terarahkan': 'arah',
'pengarah': 'arah',
'pengarahnya': 'arah',
'pengarahlah': 'arah',
'pengarahkan': 'arah',
'pengarahan': 'arah',
'mengarah': 'arah',
'mengarahnya': 'arah',
'mengarahlah': 'arah',
'mengarahkan': 'arah',
'mengarahkannya': 'arah',
'mengarahi': 'arah',
'mengarahan': 'arah',
'arah-arah': 'arah',
'arah-arahnya': 'arah',
'arah-arahan': 'arah',
'penyearah': 'arah',
'pengarahannya': 'arah',
'pengarahanan': 'arah',
'keterarahan': 'arah',
'mengarahkankan': 'arah',
'mengarahkanku': 'arah',
'mengarahkanmu': 'arah',
'menyearahkan': 'arah',
'mengarah-arahi': 'arah',
'arakan': 'arak',
'berarak': 'arak',
'berarakan': 'rarak',
'pengarak': 'arak',
'pengaraknya': 'arak',
'pengarakan': 'arak',
'mengarak': 'arak',
'mengaraknya': 'arak',
'mengarakan': 'arak',
'perarakan': 'arak',
'arak-arakan': 'arak',
'arak-arakannya': 'arak',
'berarak-arakan': 'arak',
'pengaram': 'aram',
'aram-aram': 'aram',
'mengarang': 'karang',
'mengarangnya': 'karang',
'perarangan': 'arang',
'pengarangan': 'karang',
'mengarangkan': 'arang',
'pengaransemen': 'aransemen',
'pengaransemenan': 'aransemen',
'mengaransemen': 'aransemen',
'mengaras': 'aras',
'mengarasi': 'aras',
'mengares': 'ares',
'berargumen': 'argumen',
'berargumentasi': 'argumentasi',
'berargumentasinya': 'argumentasi',
'mengari': 'ari',
'seari-arian': 'ari',
'kearifan': 'arif',
'kearifannya': 'arif',
'kearifanlah': 'arif',
'mengarifi': 'arif',
'mengarifkan': 'arif',
'mengarih': 'karih',
'mengarik': 'arik',
'mengariknya': 'arik',
'pengarip': 'arip',
'beraris': 'aris',
'berariskan': 'aris',
'berarisan': 'arisan',
'mengarit': 'arit',
'mengaritnya': 'arit',
'pengarit': 'arit',
'aronan': 'aron',
'mengaron': 'aron',
'kearsipan': 'arsip',
'kearsipannya': 'arsip',
'pengarsip': 'arsip',
'pengarsipan': 'arsip',
'mengarsipkan': 'arsip',
'mengarsipkannya': 'arsip',
'arsiran': 'arsir',
'mengarsir': 'arsir',
'artian': 'arti',
'artiannya': 'arti',
'artiani': 'arti',
'searti': 'arti',
'berarti': 'arti',
'berartinya': 'arti',
'berartikan': 'arti',
'berartii': 'arti',
'pengartian': 'arti',
'mengartikan': 'arti',
'mengartikannya': 'arti',
'keberartian': 'arti',
'mengartikelkan': 'artikel',
'berartikulasi': 'artikulasi',
'keartisan': 'artis',
'keartisannya': 'artis',
'keartistikan': 'artistik',
'aru-aru': 'aru',
'mengaruk': 'aruk',
'mengarukkan': 'aruk',
'mengarukan': 'karu',
'mengarun': 'arun',
'mengaruni': 'arun',
'arungan': 'arung',
'mengarung': 'arung',
'mengarungnya': 'arung',
'mengarungkan': 'arung',
'mengarungi': 'karung',
'mengarunginya': 'karung',
'pengarungan': 'arung',
'arung-arungan': 'arung',
'mengarus': 'arus',
'mengarusnya': 'arus',
'mengaruskan': 'arus',
'mengarwahkan': 'arwah',
'mengasa': 'asa',
'mengasalah': 'asa',
'mengasakan': 'asak',
'mengasai': 'asa',
'asa-asaan': 'asa',
'asahan': 'asah',
'asahannya': 'asah',
'berasah': 'asah',
'mengasah': 'asah',
'mengasahnya': 'asah',
'mengasahkan': 'asah',
'pengasah': 'asah',
'pengasahan': 'asah',
'diasak': 'asak',
'diasakan': 'asak',
'terasak': 'asak',
'terasaki': 'asak',
'terasakan': 'rasa',
'berasak': 'asak',
'berasakan': 'rasa',
'mengasak': 'asak',
'mengasakkan': 'asak',
'berasak-asak': 'asak',
'berasak-asakan': 'asak',
'berasal': 'asal',
'berasalnya': 'asal',
'berasalkan': 'asal',
'berasalan': 'asal',
'asalkan': 'asal',
'asal-asalan': 'asal',
'asal-asalannya': 'asal',
'mengasalkan': 'asal',
'asaman': 'asam',
'mengasam': 'kasam',
'mengasamkan': 'kasam',
'keasaman': 'asam',
'keasamannya': 'asam',
'mengasami': 'asam',
'pengasaman': 'asam',
'asam-asaman': 'asam',
'berasap': 'asap',
'berasapnya': 'asap',
'mengasap': 'asap',
'mengasapkan': 'asap',
'mengasapi': 'asap',
'perasapan': 'asap',
'mengasapinya': 'asap',
'pengasapan': 'asap',
'berasap-asap': 'asap',
'berasas': 'asas',
'berasaskan': 'asas',
'pengasas': 'asas',
'mengasaskan': 'asas',
'beraset': 'aset',
'asian': 'asi',
'asiani': 'asi',
'mengasi': 'asi',
'mengasinya': 'asi',
'mengasikan': 'asi',
'berasimilasi': 'asimilasi',
'asinan': 'asin',
'asinannya': 'asin',
'keasinan': 'asin',
'mengasini': 'asin',
'pengasinan': 'asin',
'mengasinkan': 'asin',
'terasing': 'asing',
'terasingnya': 'asing',
'terasingkan': 'asing',
'terasingi': 'asing',
'berasing': 'asing',
'berasingan': 'asing',
'mengasing': 'asing',
'mengasingkan': 'asing',
'mengasingkannya': 'asing',
'keasingan': 'asing',
'perasingan': 'asing',
'perasingannya': 'asing',
'pengasingan': 'asing',
'pengasingannya': 'asing',
'mengasingkanku': 'asing',
'berasing-asingan': 'asing',
'mengasisteni': 'asisten',
'keaslian': 'asli',
'keasliannya': 'asli',
'berasmara': 'asmara',
'mengaso': 'aso',
'berasonansi': 'asonansi',
'pengasong': 'asong',
'pengasongan': 'asong',
'mengasong': 'asong',
'mengasongkan': 'asong',
'berasosiasi': 'asosiasi',
'pengasosiasian': 'asosiasi',
'mengasosiasikan': 'asosiasi',
'mengasosiasikannya': 'asosiasi',
'teraspal': 'aspal',
'teraspalkan': 'aspal',
'beraspal': 'aspal',
'pengaspalan': 'aspal',
'pengaspalannya': 'aspal',
'beraspirasi': 'aspirasi',
'berasrama': 'asrama',
'pengasramaan': 'asrama',
'mengasramakan': 'asrama',
'keasrian': 'asri',
'keasriannya': 'asri',
'berastakona': 'astakona',
'asuhan': 'asuh',
'asuhannya': 'asuh',
'asuhannyalah': 'asuh',
'asuhanku': 'asuh',
'pengasuh': 'asuh',
'pengasuhnya': 'asuh',
'pengasuhan': 'asuh',
'mengasuh': 'asuh',
'mengasuhnya': 'asuh',
'mengasuhan': 'asuh',
'mengasuhku': 'asuh',
'pengasuhannya': 'asuh',
'mengasumsikan': 'asumsi',
'mengasumsikannya': 'asumsi',
'asungan': 'asung',
'pengasung': 'asung',
'mengasung': 'asung',
'berasuransi': 'asuransi',
'perasuransian': 'asuransi',
'perasuransiannya': 'asuransi',
'pengasuransian': 'asuransi',
'mengasuransikan': 'asuransi',
'mengasuransikannya': 'asuransi',
'keasyikan': 'asyik',
'keasyikannya': 'asyik',
'mengasyiki': 'asyik',
'mengasyikkan': 'asyik',
'mengasyikkannya': 'asyik',
'asyik-asyiknya': 'asyik',
'keasyik-asyikan': 'asyik',
'mengatak': 'atak',
'mengatakkan': 'atak',
'mengatakan': 'kata',
'pengatakan': 'atak',
'beratap': 'atap',
'beratapkan': 'atap',
'mengatap': 'atap',
'mengatapkan': 'atap',
'mengatapi': 'atap',
'mengatapan': 'atap',
'pengatapan': 'atap',
'mengatari': 'atar',
'atasan': 'atas',
'atasannya': 'atas',
'atasanlah': 'atas',
'atasannyalah': 'atas',
'atasanku': 'atas',
'atasanmu': 'atas',
'teratasi': 'atas',
'teratasinya': 'atas',
'teratasilah': 'atas',
'mengatas': 'atas',
'mengatasnya': 'atas',
'mengataskan': 'atas',
'mengatasi': 'atas',
'mengatasinya': 'atas',
'mengatasikan': 'atas',
'atas-mengatasi': 'atas',
'mengatasnamakan': 'atas nama',
'mengatasnamakannya': 'atas nama',
'ati-ati': 'ati',
'pengatoman': 'atom',
'atung-atung': 'atung',
'aturan': 'atur',
'aturannya': 'atur',
'aturanlah': 'atur',
'beratur': 'atur',
'beraturan': 'atur',
'teratur': 'atur',
'teraturnya': 'atur',
'teraturlah': 'atur',
'teraturan': 'atur',
'pengatur': 'atur',
'pengaturnya': 'atur',
'pengaturan': 'atur',
'mengatur': 'atur',
'mengaturnya': 'atur',
'mengaturkan': 'atur',
'mengaturan': 'atur',
'peraturan': 'atur',
'peraturannya': 'atur',
'peraturanlah': 'atur',
'beraturannya': 'atur',
'pengaturannya': 'atur',
'keteraturan': 'atur',
'keteraturannya': 'atur',
'mengatus': 'atus',
'mengatuskan': 'atus',
'pengatusan': 'atus',
'beraudiensi': 'audiensi',
'pengaudit': 'audit',
'pengauditan': 'audit',
'mengaudit': 'audit',
'mengauditnya': 'audit',
'mengauditkan': 'audit',
'mengaum': 'aum',
'mengaumlah': 'aum',
'mengaumkan': 'aum',
'mengaum-aum': 'aum',
'mengaum-aumkan': 'aum',
'mengaung': 'aung',
'mengaungkan': 'aung',
'mengaur': 'aur',
'keausan': 'aus',
'mengaus': 'aus',
'mengausi': 'kaus',
'mengauskan': 'aus',
'mengautopsi': 'autopsi',
'mengautopsinya': 'autopsi',
'pengawaair': 'awaair',
'pengawabau': 'awabau',
'mengawabekukan': 'awabeku',
'pengawabusa': 'awabusa',
'mengawahamakan': 'awahama',
'berawai': 'awai',
'terawai': 'awai',
'mengawai': 'awai',
'berawak': 'awak',
'berawaknya': 'awak',
'berawakkan': 'awak',
'berawakan': 'rawa',
'mengawaki': 'awak',
'mengawakinya': 'awak',
'perawakan': 'awak',
'perawakannya': 'awak',
'perawakanku': 'awak',
'memperawak': 'awak',
'pengawakan': 'awak',
'berperawakan': 'awak',
'awalan': 'awal',
'awalannya': 'awal',
'berawal': 'awal',
'berawalnya': 'awal',
'berawalan': 'awal',
'mengawali': 'kawal',
'mengawalinya': 'kawal',
'mengawalilah': 'kawal',
'mengawalengaskan': 'awalengas',
'keawaman': 'awam',
'keawamannya': 'awam',
'pengawam': 'awam',
'mengawamkan': 'awam',
'berawan': 'rawan',
'berawannya': 'rawan',
'berawanan': 'rawan',
'mengawan': 'awan',
'mengawankan': 'awan',
'mengawani': 'kawan',
'perawanan': 'awan',
'perawanannya': 'awan',
'awan-berawan': 'awan',
'awangan': 'awang',
'berawang': 'awang',
'mengawang': 'kawang',
'mengawangi': 'kawang',
'perawangan': 'awang',
'awang-awang': 'awang',
'awang-gemawang': 'awang',
'awasan': 'awas',
'awasannya': 'awas',
'berawas': 'awas',
'berawasan': 'awas',
'terawasi': 'awas',
'terawasinya': 'awas',
'pengawas': 'awas',
'pengawasnya': 'awas',
'pengawaslah': 'awas',
'pengawasi': 'awas',
'pengawasan': 'awas',
'mengawasi': 'awas',
'mengawasinya': 'awas',
'mengawasiku': 'awas',
'mengawasimu': 'awas',
'pengawasannya': 'awas',
'pengawasani': 'awas',
'pengawasanmu': 'awas',
'mengawaskan': 'awas',
'berawas-awas': 'awas',
'mengawat': 'awat',
'mengawatkan': 'kawat',
'mengawati': 'awat',
'pengawawarna': 'awawarna',
'pengawet': 'awet',
'pengawetnya': 'awet',
'pengawetan': 'awet',
'keawetan': 'awet',
'keawetannya': 'awet',
'pengawetannya': 'awet',
'mengawetkan': 'awet',
'mengawetkannya': 'awet',
'pengawinan': 'kawin',
'mengawur': 'awur',
'awut-awutan': 'awut',
'berayah': 'ayah',
'berayahkan': 'ayah',
'keayahan': 'ayah',
'keayahannya': 'ayah',
'ayakan': 'ayak',
'ayakannya': 'ayak',
'mengayak': 'ayak',
'mengayakan': 'ayak',
'pengayak': 'ayak',
'pengayakan': 'ayak',
'berayal-ayalan': 'ayal',
'ayam-ayam': 'ayam',
'ayam-ayamnya': 'ayam',
'ayam-ayaman': 'ayam',
'ayapan': 'ayap',
'mengayap': 'ayap',
'seayapan': 'ayap',
'keayapan': 'ayap',
'ayeng-ayengan': 'ayeng',
'terayomi': 'ayom',
'pengayom': 'ayom',
'pengayoman': 'ayom',
'mengayomi': 'ayom',
'mengayominya': 'ayom',
'pengayomannya': 'ayom',
'mengayum': 'ayum',
'ayunan': 'ayun',
'ayunannya': 'ayun',
'ayunanan': 'ayun',
'ayunanmu': 'ayun',
'berayun': 'ayun',
'berayunan': 'ayun',
'mengayun': 'ayun',
'mengayunnya': 'ayun',
'mengayunkan': 'ayun',
'mengayunkannya': 'ayun',
'ayun-temayun': 'ayun',
'berayun-ayun': 'ayun',
'mengayut': 'ayut',
'ayut-ayutan': 'ayut',
'mengazab': 'azab',
'mengazabkan': 'azab',
'berazam': 'azam',
'keazaman': 'azam',
'mengazamkan': 'azam',
'mengazankan': 'azan',
'babakan': 'babak',
'babakannya': 'babak',
'membabak': 'babak',
'pembabakan': 'babak',
'membaban': 'baban',
'membabani': 'baban',
'terbabang': 'babang',
'babaran': 'babar',
'terbabar': 'babar',
'membabar': 'babar',
'kebabaran': 'babar',
'pembabaran': 'babar',
'membabarkan': 'babar',
'membabas': 'babas',
'membabaskan': 'babas',
'terbabas': 'babas',
'sebabat': 'babat',
'membabat': 'babat',
'membabatnya': 'babat',
'membabatkan': 'babat',
'membabatkannya': 'babat',
'membabati': 'babat',
'pembabat': 'babat',
'pembabatan': 'babat',
'membabi': 'babi',
'berbabil': 'babil',
'pembabil': 'babil',
'perbabilan': 'babil',
'terbabit': 'babit',
'membabitkan': 'babit',
'kebablasan': 'bablas',
'kebablasannya': 'bablas',
'memperbabu': 'babu',
'bacaan': 'baca',
'bacaannya': 'baca',
'bacaanlah': 'baca',
'pembaca': 'baca',
'pembacanya': 'baca',
'pembacalah': 'baca',
'pembacakan': 'baca',
'pembacaan': 'baca',
'pembacaku': 'baca',
'terbaca': 'baca',
'terbacanya': 'baca',
'terbacalah': 'baca',
'terbacakan': 'baca',
'terbacaan': 'baca',
'membaca': 'baca',
'membacanya': 'baca',
'membacalah': 'baca',
'membacakan': 'baca',
'membacakannya': 'baca',
'membacaan': 'baca',
'membacai': 'baca',
'pembacaannya': 'baca',
'keterbacaan': 'baca',
'keterbacaannya': 'baca',
'membaca-baca': 'baca',
'membacah': 'bacah',
'membacah-bacah': 'bacah',
'baceman': 'bacem',
'membacem': 'bacem',
'bacokan': 'bacok',
'bacokannya': 'bacok',
'membacok': 'bacok',
'membacoknya': 'bacok',
'membacokkan': 'bacok',
'membacokkannya': 'bacok',
'membacoki': 'bacok',
'membacokan': 'bacok',
'membacokku': 'bacok',
'pembacok': 'bacok',
'pembacokkan': 'bacok',
'pembacokan': 'bacok',
'kebacut': 'bacut',
'terbada-bada': 'bada',
'membadai': 'badai',
'berbadai': 'badai',
'terbadai': 'badai',
'sebadan': 'badan',
'berbadan': 'badan',
'berbadankan': 'badan',
'bersebadan': 'badan',
'menyebadani': 'badan',
'bade-bade': 'bade',
'membadi': 'badi',
'berbadi': 'badi',
'membadik': 'badik',
'kebadungan': 'badung',
'membadut': 'badut',
'sebagai': 'bagai',
'sebagainya': 'bagai',
'sebagaikan': 'bagai',
'sebagaii': 'bagai',
'sebagaian': 'bagai',
'bagaikan': 'bagai',
'berbagai': 'bagai',
'berbagaii': 'bagai',
'membagaikan': 'bagai',
'keberbagaian': 'bagai',
'keberbagaiannya': 'bagai',
'berbagai-bagai': 'bagai',
'memperbagai-bagaikan': 'bagai',
'sebagaimana': 'bagaimana',
'sebagaimananya': 'bagaimana',
'membagar': 'bagar',
'berbagat': 'bagat',
'berbagati': 'bagat',
'bagian': 'bagi',
'bagiannya': 'bagi',
'bagianku': 'bagi',
'bagianmu': 'bagi',
'membagi': 'bagi',
'membaginya': 'bagi',
'membagikan': 'bagi',
'membagikannya': 'bagi',
'membagian': 'bagi',
'membagimu': 'bagi',
'terbagi': 'bagi',
'terbaginya': 'bagi',
'terbagilah': 'bagi',
'terbagikan': 'bagi',
'berbagi': 'bagi',
'berbaginya': 'bagi',
'berbagilah': 'bagi',
'berbagian': 'bagi',
'pembagi': 'bagi',
'pembaginya': 'bagi',
'pembagikan': 'bagi',
'pembagian': 'bagi',
'sebagian': 'bagi',
'sebagiannya': 'bagi',
'sebagiani': 'bagi',
'kebagian': 'bagi',
'kebagiannya': 'bagi',
'pembagiannya': 'bagi',
'membagi-bagikan': 'bagi',
'membagi-bagikannya': 'bagi',
'bagongan': 'bagong',
'membagul': 'bagul',
'bagusan': 'bagus',
'terbagus': 'bagus',
'terbagusnya': 'bagus',
'kebagusan': 'bagus',
'membaguskan': 'bagus',
'memperbagus': 'bagus',
'berbahagia': 'bahagia',
'berbahagianya': 'bahagia',
'berbahagialah': 'bahagia',
'kebahagiaan': 'bahagia',
'kebahagiaannya': 'bahagia',
'kebahagiaanlah': 'bahagia',
'kebahagiaanku': 'bahagia',
'kebahagiaanmu': 'bahagia',
'membahagiakan': 'bahagia',
'membahagiakannya': 'bahagia',
'membahagiakanku': 'bahagia',
'membahagiakanmu': 'bahagia',
'terbahak-bahak': 'bahak',
'terbahak-bahaknya': 'bahak',
'membaham': 'baham',
'membahami': 'baham',
'membahan': 'bahan',
'pembahan': 'bahan',
'pembahanan': 'bahan',
'perbahanan': 'bahan',
'berbahana': 'bahana',
'membahana': 'bahana',
'membahananya': 'bahana',
'membahanakan': 'bahana',
'terbahana': 'bahana',
'kebaharian': 'bahari',
'baharu baru': 'baharu',
'bahasan': 'bahas',
'bahasannya': 'bahas',
'membahas': 'bahas',
'membahasnya': 'bahas',
'membahaskan': 'bahas',
'membahasi': 'bahas',
'membahasan': 'bahas',
'pembahas': 'bahas',
'pembahasnya': 'bahas',
'pembahasan': 'bahas',
'pembahasannya': 'bahas',
'pembahasanan': 'bahas',
'berbahasan': 'bahas',
'perbahasan': 'bahas',
'berbahas-bahasan': 'bahas',
'berbahasa': 'bahasa',
'berbahasanya': 'bahasa',
'berbahasalah': 'bahasa',
'berbahasamu': 'bahasa',
'perbahasa': 'bahasa',
'kebahasaan': 'bahasa',
'perbahasaan': 'bahasa',
'membahasakan': 'bahasa',
'membahasakannya': 'bahasa',
'memperbahasakan': 'bahasa',
'berbahasa-bahasa': 'bahasa',
'berbahaya': 'bahaya',
'berbahayanya': 'bahaya',
'berbahayalah': 'bahaya',
'berbahayakan': 'bahaya',
'membahayakan': 'bahaya',
'membahayakannya': 'bahaya',
'membahu': 'bahu',
'bahu-membahu': 'bahu',
'bahu-membahulah': 'bahu',
'membaiat': 'baiat',
'membaiatnya': 'baiat',
'membaiatkan': 'baiat',
'sebaik': 'baik',
'sebaiknya': 'baik',
'sebaiklah': 'baik',
'sebaikan': 'baik',
'sebaiknyalah': 'baik',
'terbaik': 'baik',
'terbaiknya': 'baik',
'terbaiklah': 'baik',
'terbaiki': 'baik',
'terbaikan': 'baik',
'terbaiknyalah': 'baik',
'terbaikku': 'baik',
'terbaikmu': 'baik',
'membaik': 'baik',
'membaiknya': 'baik',
'membaiklah': 'baik',
'membaikkan': 'baik',
'membaiki': 'baik',
'membaikan': 'baik',
'berbaik': 'baik',
'berbaikkan': 'baik',
'berbaiki': 'baik',
'berbaikan': 'baik',
'kebaikan': 'baik',
'kebaikannya': 'baik',
'kebaikanku': 'baik',
'kebaikanmu': 'baik',
'kebaikan-mu': 'baik',
'membaikinya': 'baik',
'baik-baik': 'baik',
'baik-baiknya': 'baik',
'baik-baiklah': 'baik',
'baik-baiki': 'baik',
'baik-baikan': 'baik',
'pembaikan': 'baik',
'perbaikan': 'baik',
'perbaikannya': 'baik',
'perbaikanlah': 'baik',
'memperbaiki': 'baik',
'memperbaikinya': 'baik',
'memperbaikii': 'baik',
'memperbaikian': 'baik',
'sebaik-baiknya': 'baik',
'sebaik-baiknyanya': 'baik',
'berbaik-baikan': 'baik',
'berbait': 'bait',
'pembaitan': 'bait',
'berbait-bait': 'bait',
'berbaja': 'baja',
'membaja': 'baja',
'membajakan': 'bajak',
'membajai': 'baja',
'bajakan': 'bajak',
'bajakannya': 'bajak',
'pembajak': 'bajak',
'pembajaknya': 'bajak',
'pembajaklah': 'bajak',
'pembajakkan': 'bajak',
'pembajakkannya': 'bajak',
'pembajakan': 'bajak',
'membajak': 'bajak',
'membajaknya': 'bajak',
'pembajakannya': 'bajak',
'membajau': 'bajau',
'membaji': 'baji',
'pembajian': 'baji',
'kebajikan': 'bajik',
'kebajikannya': 'bajik',
'bajingan': 'bajing',
'bajingannya': 'bajing',
'berbaju': 'baju',
'berbajukan': 'baju',
'membajui': 'baju',
'membajul': 'bajul',
'berbakak': 'bakak',
'bakalan': 'bakal',
'bakalannya': 'bakal',
'bakalanlah': 'bakal',
'bakalanan': 'bakal',
'membakal': 'bakal',
'membakali': 'bakal',
'pembakalan': 'bakal',
'membakalkan': 'bakal',
'dibakar': 'bakar',
'dibakarnya': 'bakar',
'dibakarlah': 'bakar',
'dibakarkan': 'bakar',
'dibakari': 'bakar',
'membakar': 'bakar',
'membakarnya': 'bakar',
'membakarkan': 'bakar',
'membakari': 'bakar',
'membakaran': 'bakar',
'membakarku': 'bakar',
'membakarmu': 'bakar',
'pembakar': 'bakar',
'pembakarnya': 'bakar',
'pembakaran': 'bakar',
'terbakar': 'bakar',
'terbakarnya': 'bakar',
'terbakarlah': 'bakar',
'kebakaran': 'bakar',
'kebakarannya': 'bakar',
'kebakaranlah': 'bakar',
'kebakaranan': 'bakar',
'pembakarannya': 'bakar',
'membakat': 'bakat',
'berbakat': 'bakat',
'berbakatnya': 'bakat',
'membaksi': 'baksi',
'berbakti': 'bakti',
'berbaktilah': 'bakti',
'kebaktian': 'bakti',
'kebaktiannya': 'bakti',
'pembaktian': 'bakti',
'membaktikan': 'bakti',
'kebakuan': 'baku',
'pembakuan': 'baku',
'membakukan': 'baku',
'berbala-bala': 'bala',
'membalah': 'balah',
'berbalah': 'balah',
'perbalahan': 'balah',
'pembalakan': 'balak',
'pembalakannya': 'balak',
'berbalam': 'balam',
'membalam': 'balam',
'balam-balam': 'balam',
'balapan': 'balap',
'balapannya': 'balap',
'balapanan': 'balap',
'balapanku': 'balap',
'pembalap': 'balap',
'pembalapnya': 'balap',
'pembalaplah': 'balap',
'pembalapan': 'balap',
'membalap': 'balap',
'membalapnya': 'balap',
'membalaplah': 'balap',
'membalapku': 'balap',
'berbalapan': 'balap',
'membalapkan': 'balap',
'membalas dendam': 'balas dendam',
'balasan': 'balas',
'balasannya': 'balas',
'balasanan': 'balas',
'balasanku': 'balas',
'balasan-mu': 'balas',
'berbalas': 'balas',
'berbalasnya': 'balas',
'berbalasan': 'balas',
'membalas': 'balas',
'membalasnya': 'balas',
'membalaskan': 'balas',
'membalaskannya': 'balas',
'membalasi': 'balas',
'membalasan': 'balas',
'membalasku': 'balas',
'pembalas': 'balas',
'pembalasnya': 'balas',
'pembalasan': 'balas',
'pembalasannya': 'balas',
'pembalasanmu': 'balas',
'balas-membalas': 'balas',
'balas-membalasnya': 'balas',
'balas-berbalas': 'balas',
'berbalas-balasan': 'balas',
'balikan': 'balik',
'balikannya': 'balik',
'membalik': 'balik',
'membaliknya': 'balik',
'membalikkan': 'balik',
'membalikkannya': 'balik',
'membalikan': 'balik',
'berbalik': 'balik',
'berbaliknya': 'balik',
'berbaliklah': 'balik',
'berbalikkan': 'balik',
'berbalikan': 'balik',
'terbalik': 'balik',
'terbaliknya': 'balik',
'terbalikkan': 'balik',
'kebalikan': 'balik',
'kebalikannya': 'balik',
'membaliki': 'balik',
'sebaliknya': 'balik',
'sebaliknyalah': 'balik',
'pembalikan': 'balik',
'membalikkanku': 'balik',
'keterbalikan': 'balik',
'berbalik-balik': 'balik',
'membalik-balik': 'balik',
'membalik-balikkan': 'balik',
'membalik-balikan': 'balik',
'berbaling': 'baling',
'baling-baling': 'baling',
'baling-balingnya': 'baling',
'bolang-baling': 'baling',
'pembalokan': 'balok',
'baluhan': 'baluh',
'baluian': 'balui',
'membalun': 'balun',
'berbalun-balun': 'balun',
'berbalung': 'balung',
'baluran': 'balur',
'membalur': 'balur',
'membalurnya': 'balur',
'membalurkan': 'balur',
'membalurkannya': 'balur',
'membaluri': 'balur',
'balutan': 'balut',
'balutannya': 'balut',
'pembalut': 'balut',
'pembalutnya': 'balut',
'pembalutan': 'balut',
'membalut': 'balut',
'membalutnya': 'balut',
'membalutkan': 'balut',
'membaluti': 'balut',
'balut-balut': 'balut',
'sebambang': 'bambang',
'sebambangan': 'bambang',
'terbambang': 'bambang',
'bersebambangan': 'bambang',
'bambungan': 'bambung',
'membanat': 'banat',
'bancakan': 'bancak',
'bancakannya': 'bancak',
'membancang': 'bancang',
'membancarkan': 'bancar',
'kebancian': 'banci',
'kebanciannya': 'banci',
'bancuhan': 'bancuh',
'membancuh': 'bancuh',
'membancuhkan': 'bancuh',
'terbancut': 'bancut',
'bandaran': 'bandar',
'berbandar': 'bandar',
'membandar': 'bandar',
'membandari': 'bandar',
'perbandaran': 'bandar',
'membandarkan': 'bandar',
'kebandaraan': 'bandara',
'membandel': 'bandel',
'membandelnya': 'bandel',
'membandering': 'bandering',
'bandingan': 'banding',
'bandingannya': 'banding',
'bandinganlah': 'banding',
'bandingankan': 'banding',
'membanding': 'banding',
'membandingkan': 'banding',
'membandingkannya': 'banding',
'membandingi': 'banding',
'membandingan': 'banding',
'pembanding': 'banding',
'pembandingnya': 'banding',
'pembandingkan': 'banding',
'pembandingan': 'banding',
'berbanding': 'banding',
'berbandingkan': 'banding',
'berbandingan': 'banding',
'pembandingannya': 'banding',
'perbandingan': 'banding',
'perbandingannya': 'banding',
'membandingkankan': 'banding',
'membandingkanku': 'banding',
'memperbandingkan': 'banding',
'memperbandingkannya': 'banding',
'sebanding': 'banding',
'membandit': 'bandit',
'kebanditan': 'bandit',
'bandulan': 'bandul',
'membandul': 'bandul',
'sebandung': 'bandung',
'membandungi': 'bandung',
'membandut': 'bandut',
'pembandut': 'bandut',
'terbangai': 'bangai',
'membangatkan': 'bangat',
'kebangetan': 'banget',
'kebangetanlah': 'banget',
'berbangga': 'bangga',
'berbanggalah': 'bangga',
'membangga': 'bangga',
'membanggakan': 'bangga',
'membanggakannya': 'bangga',
'kebanggaan': 'bangga',
'kebanggaannya': 'bangga',
'kebanggaanlah': 'bangga',
'kebanggaanku': 'bangga',
'kebanggaanmu': 'bangga',
'membangirkan': 'bangir',
'pembangkang': 'bangkang',
'pembangkangnya': 'bangkang',
'pembangkangan': 'bangkang',
'terbangkang': 'bangkang',
'membangkang': 'bangkang',
'membangkangnya': 'bangkang',
'membangkangi': 'bangkang',
'pembangkangannya': 'bangkang',
'membangkar': 'bangkar',
'bangkitan': 'bangkit',
'bangkitannya': 'bangkit',
'berbangkit': 'bangkit',
'terbangkit': 'bangkit',
'terbangkitnya': 'bangkit',
'terbangkitkan': 'bangkit',
'pembangkit': 'bangkit',
'pembangkitnya': 'bangkit',
'pembangkitkan': 'bangkit',
'pembangkiti': 'bangkit',
'pembangkitan': 'bangkit',
'membangkit': 'bangkit',
'membangkitnya': 'bangkit',
'membangkitkan': 'bangkit',
'membangkitkannya': 'bangkit',
'membangkitan': 'bangkit',
'kebangkitan': 'bangkit',
'kebangkitannya': 'bangkit',
'kebangkitanan': 'bangkit',
'membangkit-bangkit': 'bangkit',
'membangkit-bangkitkan': 'bangkit',
'bangkotan': 'bangkot',
'kebangkrutan': 'bangkrut',
'kebangkrutannya': 'bangkrut',
'membangkrutkan': 'bangkrut',
'sebangsa': 'bangsa',
'sebangsanya': 'bangsa',
'sebangsaku': 'bangsa',
'membangsa': 'bangsa',
'membangsakan': 'bangsa',
'berbangsa': 'bangsa',
'kebangsaan': 'bangsa',
'kebangsaannya': 'bangsa',
'kebangsaanlah': 'bangsa',
'kebangsaanku': 'bangsa',
'kebangsawanan': 'bangsawan',
'kebangsawanannya': 'bangsawan',
'kebangsawananan': 'bangsawan',
'bangunan': 'bangun',
'bangunannya': 'bangun',
'bangunanlah': 'bangun',
'bangunanan': 'bangun',
'bangunanku': 'bangun',
'membangun': 'bangun',
'membangunnya': 'bangun',
'membangunkan': 'bangun',
'membangunkannya': 'bangun',
'membanguni': 'bangun',
'membangunan': 'bangun',
'pembangun': 'bangun',
'pembangunnya': 'bangun',
'pembangunan': 'bangun',
'kebangunan': 'bangun',
'pembangunannya': 'bangun',
'pembangunanlah': 'bangun',
'pembangunankan': 'bangun',
'pembangunanan': 'bangun',
'membangunkanku': 'bangun',
'membangunkanmu': 'bangun',
'bangun-bangun': 'bangun',
'bangun-bangunan': 'bangun',
'membaning': 'baning',
'berbanir': 'banir',
'sebanjar': 'banjar',
'banjaran': 'banjar',
'banjarani': 'banjar',
'berbanjar': 'banjar',
'berbanjaran': 'banjar',
'membanjarkan': 'banjar',
'berbanjar-banjar': 'banjar',
'membanjir': 'banjir',
'membanjirnya': 'banjir',
'membanjirlah': 'banjir',
'membanjirkan': 'banjir',
'membanjiri': 'banjir',
'membanjirinya': 'banjir',
'membanjirimu': 'banjir',
'kebanjiran': 'banjir',
'membanjur': 'banjur',
'perbankan': 'bank',
'perbankannya': 'bank',
'perbankanlah': 'bank',
'perbankankan': 'bank',
'perbankanan': 'bank',
'perbankanmu': 'bank',
'bantahan': 'bantah',
'bantahannya': 'bantah',
'membantah': 'bantah',
'membantahnya': 'bantah',
'membantahkan': 'bantah',
'membantahan': 'bantah',
'membantahmu': 'bantah',
'berbantah': 'bantah',
'berbantahan': 'bantah',
'pembantah': 'bantah',
'pembantahnya': 'bantah',
'pembantahan': 'bantah',
'membantahi': 'bantah',
'perbantahan': 'bantah',
'terbantahkan': 'bantah',
'terbantahkannya': 'bantah',
'bantah-bantah': 'bantah',
'bantah-bantahan': 'bantah',
'memperbantahkan': 'bantah',
'berbantah-bantah': 'bantah',
'berbantah-bantahan': 'bantah',
'bantaian': 'bantai',
'membantai': 'bantai',
'membantainya': 'bantai',
'membantaimu': 'bantai',
'pembantai': 'bantai',
'pembantaian': 'bantai',
'pembantaiannya': 'bantai',
'bantalan': 'bantal',
'bantalannya': 'bantal',
'berbantal': 'bantal',
'berbantalkan': 'bantal',
'berbantalan': 'bantal',
'membantalkan': 'bantal',
'memperbantal': 'bantal',
'bantal-bantal': 'bantal',
'pembantar': 'bantar',
'pembantaran': 'bantar',
'membantar': 'bantar',
'membantarkan': 'bantar',
'membanter': 'banter',
'bantingan': 'banting',
'bantingannya': 'banting',
'membanting': 'banting',
'membantingnya': 'banting',
'membantingkan': 'banting',
'membantingkannya': 'banting',
'pembantingan': 'banting',
'bantuan': 'bantu',
'bantuannya': 'bantu',
'bantuanlah': 'bantu',
'bantuanku': 'bantu',
'bantuanmu': 'bantu',
'pembantu': 'bantu',
'pembantunya': 'bantu',
'pembantukan': 'bantu',
'pembantuan': 'bantu',
'pembantuku': 'bantu',
'pembantumu': 'bantu',
'membantu': 'bantu',
'membantunya': 'bantu',
'membantulah': 'bantu',
'membantukan': 'bantu',
'membantui': 'bantu',
'membantuan': 'bantu',
'membantuku': 'bantu',
'membantumu': 'bantu',
'memperbantukan': 'bantu',
'sebantun': 'bantun',
'membantun': 'bantun',
'membantunnya': 'bantun',
'terbantun': 'bantun',
'membantuni': 'bantun',
'membantut': 'bantut',
'terbantut': 'bantut',
'sebanyak': 'banyak',
'sebanyaknya': 'banyak',
'sebanyaki': 'banyak',
'sebanyakan': 'banyak',
'banyakan': 'banyak',
'banyakannya': 'banyak',
'membanyak': 'banyak',
'terbanyak': 'banyak',
'terbanyaknya': 'banyak',
'terbanyaklah': 'banyak',
'terbanyaki': 'banyak',
'berbanyak': 'banyak',
'membanyaki': 'banyak',
'kebanyakan': 'banyak',
'kebanyakannya': 'banyak',
'perbanyakan': 'banyak',
'perbanyakannya': 'banyak',
'membanyakkan': 'banyak',
'memperbanyak': 'banyak',
'memperbanyaknya': 'banyak',
'memperbanyakan': 'banyak',
'banyak-banyak': 'banyak',
'banyak-banyaknya': 'banyak',
'banyak-banyaklah': 'banyak',
'banyak-banyakkan': 'banyak',
'banyak-banyakan': 'banyak',
'memperbanyakkan': 'banyak',
'berbanyak-banyak': 'banyak',
'banyolan': 'banyol',
'banyolannya': 'banyol',
'membanyol': 'banyol',
'berbapak': 'bapak',
'kebapakan': 'bapak',
'kebapakannya': 'bapak',
'pembaptis': 'baptis',
'pembaptisan': 'baptis',
'membaptis': 'baptis',
'membaptisnya': 'baptis',
'membaptiskan': 'baptis',
'pembaptisannya': 'baptis',
'membara': 'bara',
'membaranya': 'bara',
'membarakan': 'bara',
'perbaraan': 'bara',
'membarah': 'barah',
'membarak': 'barak',
'pembarap': 'barap',
'baratan': 'barat',
'pembarat': 'barat',
'pembaratan': 'barat',
'membaratkan': 'barat',
'kebarat-baratan': 'barat',
'berbareng': 'bareng',
'berbarengan': 'bareng',
'membarengi': 'bareng',
'membarenginya': 'bareng',
'berbarengannya': 'bareng',
'membarengkan': 'bareng',
'barik-barik': 'barik',
'berbarik-barik': 'barik',
'terbaring': 'baring',
'terbaringnya': 'baring',
'berbaring': 'baring',
'berbaringnya': 'baring',
'berbaringlah': 'baring',
'berbaringan': 'baring',
'pembaringan': 'baring',
'pembaringannya': 'baring',
'membaringkan': 'baring',
'membaringkannya': 'baring',
'barisan': 'baris',
'barisannya': 'baris',
'barisanan': 'baris',
'sebaris': 'baris',
'sebarisan': 'baris',
'berbaris': 'baris',
'berbarisnya': 'baris',
'membaris': 'baris',
'membariskan': 'baris',
'membariskannya': 'baris',
'baris-berbaris': 'baris',
'barongan': 'barong',
'barong tagalog': 'barong',
'terbaru': 'baru',
'terbarunya': 'baru',
'terbarulah': 'baru',
'terbarukan': 'baru',
'terbarukannya': 'baru',
'terbarui': 'baru',
'terbaruku': 'baru',
'pembaru': 'baru',
'pembarunya': 'baru',
'pembaruan': 'baru',
'membaru': 'baru',
'membarui': 'baru',
'kebaruan': 'baru',
'kebaruannya': 'baru',
'membaruinya': 'baru',
'pembaruannya': 'baru',
'membarukan': 'baru',
'memperbarui': 'baru',
'memperbaruinya': 'baru',
'baru-baru ini': 'baru',
'pembarut': 'barut',
'berbarut': 'barut',
'membarut': 'barut',
'pembarutan': 'barut',
'membarutkan': 'barut',
'membarut-barut': 'barut',
'berbasa-basi': 'basa-basi',
'basahan': 'basah',
'basahannya': 'basah',
'membasahi': 'basah',
'membasahinya': 'basah',
'pembasahan': 'basah',
'pembasahannya': 'basah',
'membasahkan': 'basah',
'berbasah-basah': 'basah',
'berbasah-basahan': 'basah',
'kebasah-basahan': 'basah',
'membasi': 'basi',
'kebasian': 'basi',
'membasikan': 'basi',
'berbasiskan': 'basis',
'albasit': 'basit',
'pembasmi': 'basmi',
'pembasmian': 'basmi',
'terbasmi': 'basmi',
'membasmi': 'basmi',
'membasminya': 'basmi',
'pembasmiannya': 'basmi',
'basuhan': 'basuh',
'pembasuh': 'basuh',
'pembasuhan': 'basuh',
'membasuh': 'basuh',
'membasuhnya': 'basuh',
'membasuhkan': 'basuh',
'membasuhkannya': 'basuh',
'membasuhi': 'basuh',
'basungan': 'basung',
'membasung': 'basung',
'berbasut': 'basut',
'membasut': 'basut',
'terbata-bata': 'bata-bata',
'kebata-bataan': 'bata-bata',
'membatak': 'batak',
'membatakkan': 'batak',
'membatakkannya': 'batak',
'membatakan': 'batak',
'pembatak': 'batak',
'pembatakan': 'batak',
'pembatalan': 'batal',
'pembatalannya': 'batal',
'membatalkan': 'batal',
'membatalkannya': 'batal',
'membatalkankan': 'batal',
'batangan': 'batang',
'batangannya': 'batang',
'batanganmu': 'batang',
'sebatang': 'batang',
'sebatangnya': 'batang',
'membatang': 'batang',
'batasan': 'batas',
'batasannya': 'batas',
'pembatas': 'batas',
'pembatasnya': 'batas',
'pembatasi': 'batas',
'pembatasan': 'batas',
'berbatas': 'batas',
'berbataskan': 'batas',
'berbatasan': 'batas',
'membatas': 'batas',
'membataskan': 'batas',
'membatasi': 'batas',
'membatasan': 'batas',
'terbatas': 'batas',
'terbatasnya': 'batas',
'terbataslah': 'batas',
'terbataskan': 'batas',
'terbatasi': 'batas',
'terbatasan': 'batas',
'membatasinya': 'batas',
'pembatasannya': 'batas',
'pembatasanlah': 'batas',
'perbatasan': 'batas',
'perbatasannya': 'batas',
'perbatasanlah': 'batas',
'perbatasanan': 'batas',
'keterbatasan': 'batas',
'keterbatasannya': 'batas',
'keterbatasanku': 'batas',
'sebati': 'bati',
'sebatian': 'bati',
'batikan': 'batik',
'batikannya': 'batik',
'pembatik': 'batik',
'pembatiknya': 'batik',
'pembatikan': 'batik',
'membatik': 'batik',
'membatiknya': 'batik',
'membatikkan': 'batik',
'membatiki': 'batik',
'pembatikannya': 'batik',
'membatin': 'batin',
'membatinkan': 'batin',
'berbatin': 'batin',
'kebatinan': 'batin',
'kebatinannya': 'batin',
'pembatubaraan': 'batu bara',
'batuan': 'batu',
'batuannya': 'batu',
'membatu': 'batu',
'membatunya': 'batu',
'membatumu': 'batu',
'berbatu': 'batu',
'berbatuan': 'batu',
'membatui': 'batu',
'pembatuan': 'batu',
'berbatu-batu': 'batu',
'berbatu-batuan': 'batu',
'berbatuk': 'batuk',
'batuk-batuk': 'batuk',
'batuk-batuknya': 'batuk',
'membatukkan': 'batuk',
'membatukkannya': 'batuk',
'terbatuk-batuk': 'batuk',
'batung-batung': 'batung',
'sebau': 'bau',
'berbau': 'bau',
'berbaunya': 'bau',
'terbau': 'bau',
'terbaunya': 'bau',
'terbaukan': 'bau',
'membaui': 'bau',
'membauinya': 'bau',
'bau-bauan': 'bau',
'bauksit': 'bauk',
'bauksitnya': 'bauk',
'membauni': 'baun',
'bauran': 'baur',
'baurannya': 'baur',
'membaur': 'baur',
'membaurnya': 'baur',
'membaurlah': 'baur',
'membaurkan': 'baur',
'membaurkannya': 'baur',
'terbaur': 'baur',
'terbaurnya': 'baur',
'berbaur': 'baur',
'berbaurnya': 'baur',
'berbaurlah': 'baur',
'perbauran': 'baur',
'pembauran': 'baur',
'pembaurannya': 'baur',
'memperbaurkan': 'baur',
'bawaan': 'bawa',
'bawaannya': 'bawa',
'bawaanku': 'bawa',
'bawaanmu': 'bawa',
'terbawa': 'bawa',
'terbawanya': 'bawa',
'terbawalah': 'bawa',
'pembawa': 'bawa',
'pembawanya': 'bawa',
'pembawaan': 'bawa',
'membawa': 'bawa',
'membawanya': 'bawa',
'membawakan': 'bawa',
'membawakannya': 'bawa',
'membawai': 'bawa',
'membawaku': 'bawa',
'membawamu': 'bawa',
'berbawaan': 'bawa',
'pembawaannya': 'bawa',
'sepembawa': 'bawa',
'membawakanku': 'bawa',
'membawa-bawa': 'bawa',
'membawa-bawanya': 'bawa',
'berpembawaan': 'bawa',
'bawahan': 'bawah',
'bawahannya': 'bawah',
'bawahanlah': 'bawah',
'bawahanku': 'bawah',
'bawahanmu': 'bawah',
'sebawah': 'bawah',
'di bawah': 'bawah',
'terbawah': 'bawah',
'terbawahnya': 'bawah',
'terbawahlah': 'bawah',
'sebawahan': 'bawah',
'membawahi': 'bawah',
'membawahinya': 'bawah',
'membawahkan': 'bawah',
'membawang': 'bawang',
'berbawang': 'bawang',
'pembawang': 'bawang',
'membawangi': 'bawang',
'sebaya': 'baya',
'sebayanya': 'baya',
'sebayaku': 'baya',
'terbayan': 'bayan',
'membayankan': 'bayan',
'bayangan': 'bayang',
'bayangannya': 'bayang',
'bayangankan': 'bayang',
'bayanganku': 'bayang',
'bayanganmu': 'bayang',
'terbayang': 'bayangan',
'terbayangnya': 'bayangan',
'terbayanglah': 'bayangan',
'terbayangkan': 'bayangan',
'terbayangi': 'bayangan',
'membayang': 'bayangan',
'membayangnya': 'bayangan',
'membayangkan': 'bayangan',
'membayangkannya': 'bayangan',
'membayangi': 'bayangan',
'membayangan': 'bayangan',
'berbayang': 'bayang',
'membayanginya': 'bayang',
'membayangii': 'bayang',
'pembayangan': 'bayangan',
'bayang-bayang': 'bayangan',
'bayang-bayangnya': 'bayangan',
'bayang-bayangi': 'bayangan',
'bayang-bayangku': 'bayangan',
'bayang-bayangmu': 'bayangan',
'berbayang-bayang': 'bayang',
'terbayang-bayang': 'bayangan',
'terbayang-bayangi': 'bayangan',
'membayang-bayangi': 'bayangan',
'membayang-bayanginya': 'bayangan',
'membayang-bayangkan': 'bayang',
'bayaran': 'bayar',
'bayarannya': 'bayar',
'berbayar': 'bayar',
'berbayarnya': 'bayar',
'berbayarkan': 'bayar',
'berbayaran': 'bayar',
'membayar': 'bayar',
'membayarnya': 'bayar',
'membayarkan': 'bayar',
'membayarkannya': 'bayar',
'membayari': 'bayar',
'membayaran': 'bayar',
'membayarnyalah': 'bayar',
'membayarku': 'bayar',
'membayarmu': 'bayar',
'pembayar': 'bayar',
'pembayarnya': 'bayar',
'pembayarkan': 'bayar',
'pembayaran': 'bayar',
'membayarinya': 'bayar',
'pembayarannya': 'bayar',
'pembayaranan': 'bayar',
'kebayi-bayian': 'bayi',
'membayonet': 'bayonet',
'membayong': 'bayong',
'bayuan': 'bayu',
'kebayuan': 'bayu',
'pembayun': 'bayun',
'membea': 'bea',
'kebebalan': 'bebal',
'kebebalannya': 'bebal',
'membebani': 'beban',
'membebaninya': 'beban',
'membebaniku': 'beban',
'membebanimu': 'beban',
'pembebanan': 'beban',
'pembebanannya': 'beban',
'membebankan': 'beban',
'membebankannya': 'beban',
'terbebang': 'bebang',
'kebebangan': 'bebang',
'berbebar': 'bebar',
'terbebar': 'bebar',
'pembebas': 'bebas',
'pembebaskan': 'bebas',
'pembebasan': 'bebas',
'terbebas': 'bebas',
'terbebasnya': 'bebas',
'terbebaskan': 'bebas',
'kebebasan': 'bebas',
'kebebasannya': 'bebas',
'kebebasanku': 'bebas',
'kebebasanmu': 'bebas',
'pembebasannya': 'bebas',
'membebaskan': 'bebas',
'membebaskannya': 'bebas',
'membebaskanku': 'bebas',
'membebaskanmu': 'bebas',
'membebasmurnikan': 'bebas murni',
'membebastugaskan': 'bebas tugas',
'membebastugaskannya': 'bebas tugas',
'membebat': 'bebat',
'membebatnya': 'bebat',
'membebatkan': 'bebat',
'pembebat': 'bebat',
'pembebatan': 'bebat',
'pembebek': 'bebek',
'membebek': 'bebek',
'membebekan': 'bebek',
'beberan': 'beber',
'membeber': 'beber',
'membebernya': 'beber',
'membeberkan': 'beber',
'membeberkannya': 'beber',
'membeberan': 'beber',
'pembeberan': 'beber',
'pembeberannya': 'beber',
'seberapa': 'beberapa',
'seberapanya': 'beberapa',
'buyutan': 'buyut',
'buyutannya': 'buyut',
'bebuyutan': 'buyut',
'bebuyutannya': 'buyut',
'kebuyutan': 'buyut',
'berbecak-becak': 'becak',
'berbeda': 'beda',
'berbedanya': 'beda',
'berbedalah': 'beda',
'berbedai': 'beda',
'berbedaan': 'beda',
'pembeda': 'beda',
'pembedanya': 'beda',
'pembedakan': 'beda',
'pembedaan': 'beda',
'pembedaannya': 'beda',
'berbedaannya': 'beda',
'perbedaan': 'beda',
'perbedaannya': 'beda',
'perbedaanlah': 'beda',
'membedakan': 'beda',
'membedakannya': 'beda',
'membedakanlah': 'beda',
'membedakanmu': 'beda',
'berbeda-beda': 'beda',
'berbeda-bedanya': 'beda',
'memperbedakan': 'beda',
'terbeda-bedakan': 'beda',
'membeda-bedakan': 'beda',
'membeda-bedakannya': 'beda',
'membeda-bedakanmu': 'beda',
'membedah': 'bedah',
'membedahnya': 'bedah',
'membedahkan': 'bedah',
'pembedah': 'bedah',
'pembedahan': 'bedah',
'pembedahannya': 'bedah',
'berbedak': 'bedak',
'membedaki': 'bedak',
'membedakkan': 'bedak',
'membedal': 'bedal',
'membedel': 'bedel',
'membedil': 'bedil',
'membedilnya': 'bedil',
'berbedil': 'bedil',
'membedili': 'bedil',
'sepembedil': 'bedil',
'bedil-bedal': 'bedil',
'bedil-bedilan': 'bedil',
'berbedil-bedilan': 'bedil',
'bedolan': 'bedol',
'terbedol': 'bedol',
'membedol': 'bedol',
'pembedolan': 'bedol',
'bedungan': 'bedung',
'membedung': 'bedung',
'berbega': 'bega',
'berbegai': 'bega',
'membega': 'bega',
'berbega-bega': 'bega',
'membegal': 'begal',
'membegalnya': 'begal',
'pembegalan': 'begal',
'pembegalannya': 'begal',
'membegar': 'begar',
'kebegaran': 'begar',
'sebegini': 'begini',
'sebegininya': 'begini',
'beginian': 'begini',
'membeginikan': 'begini',
'begituan': 'begitu',
'begituanlah': 'begitu',
'sebegitu': 'begitu',
'sebegitunya': 'begitu',
'sebegitunyalah': 'begitu',
'membegitukan': 'begitu',
'membehandel': 'behandel',
'kebejatan': 'bejat',
'kebejatannya': 'bejat',
'membejatkan': 'bejat',
'membeka': 'beka',
'berbeka': 'beka',
'terbeka': 'beka',
'berbeka-beka': 'beka',
'berbekal': 'bekal',
'berbekalkan': 'bekal',
'pembekal': 'bekal',
'pembekalan': 'bekal',
'membekali': 'bekal',
'membekalinya': 'bekal',
'membekalimu': 'bekal',
'perbekalan': 'bekal',
'perbekalannya': 'bekal',
'pembekalannya': 'bekal',
'membekalkan': 'bekal',
'bekal-bekalan': 'bekal',
'pembekam': 'bekam',
'pembekaman': 'bekam',
'membekam': 'bekam',
'membekap': 'bekap',
'membekapnya': 'bekap',
'membekapkan': 'bekap',
'berbekas': 'bekas',
'membekas': 'bekas',
'membekasnya': 'bekas',
'membekaskan': 'bekas',
'kebekenan': 'beken',
'bekerja': 'kerja',
'bekerjanya': 'kerja',
'bekerjalah': 'kerja',
'bekerjakan': 'kerja',
'bekerjai': 'kerja',
'bekerjaan': 'kerja',
'bekerjamu': 'kerja',
'pekerja': 'kerja',
'pekerjanya': 'kerja',
'pekerjalah': 'kerja',
'pekerjakan': 'kerja',
'pekerjaan': 'kerja',
'pekerjaku': 'kerja',
'pekerjamu': 'kerja',
'sekerja': 'kerja',
'sekerjanya': 'kerja',
'pekerjaannya': 'kerja',
'pekerjaanlah': 'kerja',
'pekerjaanku': 'kerja',
'pekerjaanmu': 'kerja',
'pengerjaan': 'kerja',
'pengerjaannya': 'kerja',
'tekerjakan': 'kerja',
'mengerjakan': 'kerja',
'mengerjakannya': 'kerja',
'mengerjakankan': 'kerja',
'sepekerjaan': 'kerja',
'sepekerjaannya': 'kerja',
'mempekerjakan': 'kerja',
'mempekerjakannya': 'kerja',
'mempekerjakanku': 'kerja',
'mempekerjakanmu': 'kerja',
'bekuan': 'beku',
'bekuannya': 'beku',
'membeku': 'beku',
'membekunya': 'beku',
'membekukan': 'beku',
'membekukannya': 'beku',
'membekuan': 'beku',
'pembeku': 'beku',
'pembekukan': 'beku',
'pembekuan': 'beku',
'kebekuan': 'beku',
'kebekuannya': 'beku',
'pembekuannya': 'beku',
'membekuk': 'bekuk',
'membekuknya': 'bekuk',
'membekukkan': 'bekuk',
'mengebel': 'bel',
'membela': 'bela',
'membelanya': 'bela',
'membelai': 'bela',
'membelaku': 'bela',
'membelamu': 'bela',
'pembela': 'bela',
'pembelanya': 'bela',
'pembelakan': 'bela',
'pembelaan': 'bela',
'pembelamu': 'bela',
'pembelaannya': 'bela',
'pembelaanku': 'bela',
'belahan': 'belah',
'belahannya': 'belah',
'sebelah': 'belah',
'sebelahnya': 'belah',
'sebelahan': 'belah',
'sebelahku': 'belah',
'sebelahmu': 'belah',
'pembelah': 'belah',
'pembelahan': 'belah',
'membelah': 'belah',
'membelahnya': 'belah',
'berbelah': 'belah',
'berbelahan': 'belah',
'menyebelah': 'belah',
'pembelahannya': 'belah',
'menyebelahi': 'belah',
'bersebelahan': 'belah',
'bersebelahanlah': 'belah',
'menyebelahkan': 'belah',
'berbelah-belah': 'belah',
'sebelah-menyebelah': 'belah',
'terbelahak': 'belahak',
'membelahak': 'belahak',
'belaian': 'belai',
'belaiannya': 'belai',
'membelainya': 'belai',
'membelai-belai': 'belai',
'membelai-belainya': 'belai',
'belakangan': 'belakang',
'belakangannya': 'belakang',
'belakanganlah': 'belakang',
'belakanganan': 'belakang',
'membelakang': 'belakang',
'membelakangkan': 'belakang',
'membelakangi': 'belakang',
'terbelakang': 'belakang',
'terbelakangnya': 'belakang',
'terbelakangan': 'belakang',
'ke belakang': 'belakang',
'membelakanginya': 'belakang',
'terkebelakang': 'belakang',
'pembelakangan': 'belakang',
'keterbelakangan': 'belakang',
'keterbelakangannya': 'belakang',
'mengebelakangkan': 'belakang',
'memperbelakangkan': 'belakang',
'berbelakang-belakangan': 'belakang',
'belalakan': 'belalak',
'membelalak': 'belalak',
'membelalakkan': 'belalak',
'membelalakan': 'belalak',
'terbelalak': 'belalak',
'membelalang': 'belalang',
'membelalangkan': 'belalang',
'terbelam': 'belam',
'membelam': 'belam',
'membelandakan': 'belanda',
'kebelanda-belandaan': 'belanda',
'membelandang': 'belandang',
'membelandangkan': 'belandang',
'belandongan': 'belandong',
'pembelandongan': 'belandong',
'berbelang-belang': 'belang',
'sebelanga': 'belanga',
'terbelangah': 'langah',
'belangiran': 'belangir',
'belanjaan': 'belanja',
'belanjaannya': 'belanja',
'belanjaanku': 'belanja',
'belanjaanmu': 'belanja',
'berbelanja': 'belanja',
'berbelanjanya': 'belanja',
'berbelanjalah': 'belanja',
'berbelanjaan': 'belanja',
'berbelanjaku': 'belanja',
'membelanjai': 'belanja',
'pembelanjaan': 'belanja',
'pembelanjaannya': 'belanja',
'perbelanjaan': 'belanja',
'perbelanjaannya': 'belanja',
'perbelanjaanlah': 'belanja',
'perbelanjaanmu': 'belanja',
'membelanjakan': 'belanja',
'membelanjakannya': 'belanja',
'membelar': 'belar',
'selar-belar': 'belar',
'belasan': 'belas',
'belasannya': 'belas',
'belasanlah': 'belas',
'sebelas': 'belas',
'sebelasnya': 'belas',
'sebelasan': 'belas',
'pembelas': 'belas',
'pembelasan': 'belas',
'membelaskan': 'belas',
'kesebelasan': 'belas',
'kesebelasannya': 'belas',
'berbelaskasihan': 'belas',
'membelasah': 'belasah',
'berbelasungkawa': 'belasungkawa',
'membelasut': 'belasut',
'membelat': 'belat',
'membelau': 'belau',
'kebelauan': 'belau',
'berbelau-belauan': 'belau',
'membelek': 'belek',
'terbelelang': 'belelang',
'membelendung': 'belendung',
'terbelenggu': 'belenggu',
'terbelenggunya': 'belenggu',
'membelenggu': 'belenggu',
'membelenggunya': 'belenggu',
'membelengketkan': 'belengket',
'membelenting': 'belenting',
'membelentingkan': 'belenting',
'belian': 'beli',
'beliannya': 'beli',
'beliani': 'beli',
'terbeli': 'beli',
'terbelinya': 'beli',
'membeli': 'beli',
'membelinya': 'beli',
'membelikan': 'beli',
'membelikannya': 'beli',
'membelian': 'beli',
'membeliku': 'beli',
'membelimu': 'beli',
'pembeli': 'beli',
'pembelinya': 'beli',
'pembelilah': 'beli',
'pembelikan': 'beli',
'pembelii': 'beli',
'pembelian': 'beli',
'pembeliannya': 'beli',
'pembelianku': 'beli',
'pembelianmu': 'beli',
'membelikanku': 'beli',
'membelikanmu': 'beli',
'membeli-beli': 'beli',
'berbeli-beli': 'beli',
'berbeli-belian': 'beli',
'kebeliaan': 'belia',
'terbeliak': 'beliak',
'membeliak': 'beliak',
'membeliakkan': 'beliak',
'berbelian': 'belian',
'beliau-beliau': 'beliau',
'beliau-beliaulah': 'beliau',
'belimbingan': 'belimbing',
'berbelimbing': 'belimbing',
'terbelingkang': 'belingkang',
'belingsatan': 'belingsat',
'terbelingut': 'belingut',
'terbelintang': 'belintang',
'berbelintang': 'belintang',
'berbelintangan': 'belintang',
'membelintangkan': 'belintang',
'terbelit': 'belit',
'terbelitnya': 'belit',
'berbelit': 'belit',
'berbelitnya': 'belit',
'membelit': 'belit',
'membelitnya': 'belit',
'membelitkan': 'belit',
'berbelit-belit': 'belit',
'berbelit-belitnya': 'belit',
'berbelit-belitlah': 'belit',
'membelit-belitkan': 'belit',
'belokan': 'belok',
'belokannya': 'belok',
'belokanku': 'belok',
'membelok': 'belok',
'membeloknya': 'belok',
'membelokkan': 'belok',
'membelokkannya': 'belok',
'membelokan': 'belok',
'berbelok': 'belok',
'berbeloknya': 'belok',
'berbeloklah': 'belok',
'berbelokkan': 'belok',
'pembelokan': 'belok',
'berbelok-belok': 'belok',
'berbelon': 'belon',
'belongkotan': 'belongkot',
'berbelongsong': 'belongsong',
'membelongsongi': 'belongsong',
'membelontang': 'belontang',
'pembelot': 'belot',
'pembelotnya': 'belot',
'pembelotan': 'belot',
'membelot': 'belot',
'membelotnya': 'belot',
'membelotkan': 'belot',
'pembelotannya': 'belot',
'membelu': 'belu',
'membelu-belai': 'belu-belai',
'membeludak': 'beludak',
'membeludaknya': 'beludak',
'membelukar': 'belukar',
'berbelulang': 'belulang',
'sebelum': 'belum',
'sebelumnya': 'belum',
'sebelumi': 'belum',
'sebelumnyalah': 'belum',
'sebelumku': 'belum',
'sebelummu': 'belum',
'belum-belum': 'belum',
'membelungsing': 'belungsing',
'berbelut': 'belut',
'membembam': 'bembam',
'berbenah': 'benah',
'berbenahlah': 'benah',
'membenahi': 'benah',
'membenahinya': 'benah',
'pembenahan': 'benah',
'pembenahannya': 'benah',
'pembenahanan': 'benah',
'berbenak': 'benak',
'membenalu': 'benalu',
'benaman': 'benam',
'berbenam': 'benam',
'terbenam': 'benam',
'terbenamnya': 'benam',
'terbenamlah': 'benam',
'terbenamkan': 'benam',
'membenam': 'benam',
'membenamnya': 'benam',
'membenamkan': 'benam',
'membenamkannya': 'benam',
'membenami': 'benam',
'membenaman': 'benam',
'membenang': 'benang',
'membenangkan': 'benang',
'berbenang-benang': 'benang',
'benaran': 'benar',
'membenar': 'benar',
'membenarnya': 'benar',
'membenarkan': 'benar',
'membenarkannya': 'benar',
'membenari': 'benar',
'membenaran': 'benar',
'berbenar': 'benar',
'terbenar': 'benar',
'kebenaran': 'benar',
'kebenarannya': 'benar',
'kebenaranlah': 'benar',
'kebenarankan': 'benar',
'kebenaranan': 'benar',
'kebenaranmu': 'benar',
'sebenarnya': 'benar',
'sebenarnyanya': 'benar',
'sebenarnyalah': 'benar',
'sebenarnyai': 'benar',
'pembenaran': 'benar',
'pembenarannya': 'benar',
'benar-benar': 'benar',
'benar-benarlah': 'benar',
'benar-benaran': 'benar',
'memperbenar': 'benar',
'membenar-benar': 'benar',
'berbenar-benar': 'benar',
'membenar-benari': 'benar',
'membenara': 'benara',
'membenarakan': 'benara',
'berbencah': 'bencah',
'membencah': 'bencah',
'berbencah-bencah': 'bencah',
'membencanai': 'bencana',
'membencanakan': 'bencana',
'pembenci': 'benci',
'pembencinya': 'benci',
'pembencian': 'benci',
'pembenciku': 'benci',
'pembencimu': 'benci',
'membenci': 'benci',
'membencinya': 'benci',
'membenciku': 'benci',
'membencimu': 'benci',
'kebencian': 'benci',
'kebenciannya': 'benci',
'kebencianlah': 'benci',
'kebencianku': 'benci',
'kebencianmu': 'benci',
'kebencian-mu': 'benci',
'membencikan': 'benci',
'berbencol-bencol': 'bencol',
'berbenda': 'benda',
'kebendaan': 'benda',
'pembendaan': 'benda',
'perbendaan': 'benda',
'perbendaannya': 'benda',
'membendakan': 'benda',
'perbendaharaan': 'bendahara',
'membenderai': 'bendera',
'kebenderangan': 'benderang',
'membendi': 'bendi',
'berbendi': 'bendi',
'bendungan': 'bendung',
'bendungannya': 'bendung',
'bendunganan': 'bendung',
'terbendung': 'bendung',
'terbendungnya': 'bendung',
'terbendungkan': 'bendung',
'pembendung': 'bendung',
'pembendungnya': 'bendung',
'pembendungan': 'bendung',
'membendung': 'bendung',
'membendungnya': 'bendung',
'terbengang': 'bengang',
'membengang': 'bengang',
'berbenggil-benggil': 'benggil',
'benggolan': 'benggol',
'benggolannya': 'benggol',
'membengis': 'bengis',
'kebengisan': 'bengis',
'kebengisannya': 'bengis',
'membengisi': 'bengis',
'bengkahan': 'bengkah',
'membengkak': 'bengkak',
'membengkaknya': 'bengkak',
'membengkakkan': 'bengkak',
'membengkakan': 'bengkak',
'pembengkakan': 'bengkak',
'pembengkakannya': 'bengkak',
'kebengkalan': 'bengkal',
'terbengkalai': 'bengkalai',
'terbengkalainya': 'bengkalai',
'terbengkalaikan': 'bengkalai',
'membengkalaikan': 'bengkalai',
'membengkar': 'bengkar',
'membengkel': 'bengkel',
'membengkelkan': 'bengkel',
'membengkeli': 'bengkel',
'perbengkelan': 'bengkel',
'terbengkil-bengkil': 'bengkil',
'membengkos': 'bengkos',
'berbengkung': 'bengkung',
'membengkung': 'bengkung',
'terbengong-bengong': 'bengong',
'berbenguk': 'benguk',
'berbenih': 'benih',
'pembenih': 'benih',
'pembenihan': 'benih',
'pembenihannya': 'benih',
'perbenihan': 'benih',
'membenihkan': 'benih',
'pembening': 'bening',
'membening': 'bening',
'membeningkan': 'bening',
'kebeningan': 'bening',
'kebeningannya': 'bening',
'pembeningan': 'bening',
'benjolan': 'benjol',
'benjolannya': 'benjol',
'berbenjol': 'benjol',
'bentakan': 'bentak',
'bentakannya': 'bentak',
'membentak': 'bentak',
'membentaknya': 'bentak',
'bentangan': 'bentang',
'bentangannya': 'bentang',
'terbentang': 'bentang',
'terbentangnya': 'bentang',
'terbentanglah': 'bentang',
'terbentangkan': 'bentang',
'membentang': 'bentang',
'membentangnya': 'bentang',
'membentanglah': 'bentang',
'membentangkan': 'bentang',
'membentangkannya': 'bentang',
'membentangi': 'bentang',
'membentangan': 'bentang',
'sebentar': 'bentar',
'sebentarnya': 'bentar',
'sebentarlah': 'bentar',
'berbentar': 'bentar',
'sesebentar': 'bentar',
'membentari': 'bentar',
'perbentaran': 'bentar',
'membentarkan': 'bentar',
'sebentar-sebentar': 'sebentar',
'berbenteh': 'benteh',
'membenteh': 'benteh',
'berbenteng': 'benteng',
'membentengi': 'benteng',
'membentenginya': 'benteng',
'kebentok': 'bentok',
'berbentol-bentol': 'bentol',
'berbentong-bentong': 'bentong',
'bentrokan': 'bentrok',
'bentrokannya': 'bentrok',
'berbentrok': 'bentrok',
'berbentrokan': 'bentrok',
'perbentrokan': 'bentrok',
'membentrokkan': 'bentrok',
'bentukan': 'bentuk',
'bentukannya': 'bentuk',
'membentuk': 'bentuk',
'membentuknya': 'bentuk',
'membentukkan': 'bentuk',
'membentukan': 'bentuk',
'membentukku': 'bentuk',
'terbentuk': 'bentuk',
'terbentuknya': 'bentuk',
'terbentuklah': 'bentuk',
'terbentukkan': 'bentuk',
'terbentukan': 'bentuk',
'pembentuk': 'bentuk',
'pembentuknya': 'bentuk',
'pembentukkan': 'bentuk',
'pembentukkannya': 'bentuk',
'pembentukan': 'bentuk',
'berbentuk': 'bentuk',
'berbentukan': 'bentuk',
'pembentukannya': 'bentuk',
'benturan': 'bentur',
'benturannya': 'bentur',
'kebentur': 'bentur',
'terbentur': 'bentur',
'terbenturnya': 'bentur',
'membentur': 'bentur',
'membenturnya': 'bentur',
'membenturkan': 'bentur',
'membenturkannya': 'bentur',
'berbenturan': 'bentur',
'berbenturannya': 'bentur',
'perbenturan': 'bentur',
'terbentus': 'bentus',
'benuman': 'benum',
'membenum': 'benum',
'membeo': 'beo',
'pembeo': 'beo',
'memberakan': 'bera',
'meracun': 'racun',
'meracunnya': 'racun',
'meracunkan': 'racun',
'meracuni': 'racun',
'meracunan': 'racun',
'beracun': 'racun',
'beracunnya': 'racun',
'peracun': 'racun',
'peracunnya': 'racun',
'peracunan': 'racun',
'meracuninya': 'racun',
'keracunan': 'racun',
'keracunannya': 'racun',
'keracunanan': 'racun',
'meragi': 'ragi',
'beragi': 'ragi',
'beraginya': 'ragi',
'peragian': 'ragi',
'meragikan': 'ragi',
'keberahian': 'berahi',
'memberahikan': 'berahi',
'berberaian': 'berai',
'memberai-beraikan': 'berai',
'terberak': 'berak',
'berambu': 'rambu',
'perambuan': 'rambu',
'rambu-rambu': 'rambu',
'rambu-rambunya': 'rambu',
'serambut': 'rambut',
'serambutan': 'rambut',
'merambut': 'rambut',
'perambut': 'rambut',
'berambut': 'rambut',
'memberandal': 'berandal',
'memberang': 'berang',
'memberangkan': 'berang',
'memberangi': 'berang',
'pemberang': 'berang',
'pemberangkan': 'berang',
'berangasan': 'berangas',
'kerangka': 'rangka',
'kerangkanya': 'rangka',
'kerangkai': 'rangka',
'berangka': 'rangka',
'berangkai': 'rangkai',
'merangkakan': 'rangka',
'keberangkatan': 'berangkat',
'keberangkatannya': 'berangkat',
'keberangkatanku': 'berangkat',
'keberangkatanmu': 'berangkat',
'pemberangkatan': 'berangkat',
'pemberangkatannya': 'berangkat',
'pemberangkatanku': 'berangkat',
'memberangkatkan': 'berangkat',
'memberangkatkannya': 'berangkat',
'merangsang': 'rangsang',
'merangsangnya': 'rangsang',
'merangsangan': 'rangsang',
'berangsang': 'rangsang',
'terangsang': 'rangsang',
'terangsangnya': 'rangsang',
'rangsangan': 'rangsang',
'rangsangannya': 'rangsang',
'rangsanganlah': 'rangsang',
'perangsang': 'rangsang',
'perangsangan': 'rangsang',
'perangsangannya': 'rangsang',
'merangsangkan': 'rangsang',
'memberangus': 'berangus',
'memberangusnya': 'berangus',
'memberanguskan': 'berangus',
'pemberangus': 'berangus',
'pemberangusan': 'berangus',
'pemberani': 'berani',
'pemberaninya': 'berani',
'keberanian': 'berani',
'keberaniannya': 'berani',
'keberanianlah': 'berani',
'keberanianmu': 'berani',
'memberanikan': 'berani',
'memberanikannya': 'berani',
'terberanikan': 'berani',
'berani-berani': 'berani',
'berani-beraninya': 'berani',
'berani-beranian': 'berani',
'berberani-berani': 'berani',
'berantakan': 'berantak',
'berantakannya': 'berantak',
'berantakanlah': 'berantak',
'memberantakkan': 'berantak',
'memberantas': 'berantas',
'memberantasnya': 'berantas',
'memberantaskan': 'berantas',
'memberantasi': 'berantas',
'memberantasan': 'berantas',
'pemberantas': 'berantas',
'pemberantasi': 'berantas',
'pemberantasan': 'berantas',
'pemberantasannya': 'berantas',
'pemberantasanan': 'berantas',
'berasa': 'rasa',
'berasanya': 'rasa',
'berasalah': 'rasa',
'berasai': 'rasa',
'berasaan': 'rasa',
'perasa': 'rasa',
'perasanya': 'rasa',
'perasaan': 'rasa',
'terasa': 'rasa',
'terasanya': 'rasa',
'terasalah': 'rasa',
'merasa': 'rasa',
'merasanya': 'rasa',
'merasalah': 'rasa',
'merasakan': 'rasa',
'merasakannya': 'rasa',
'merasai': 'rasa',
'merasaan': 'rasa',
'serasa': 'rasa',
'merasainya': 'rasa',
'rasanya': 'rasa',
'rasanyanya': 'rasa',
'perasaannya': 'rasa',
'perasaanlah': 'rasa',
'perasaanku': 'rasa',
'perasaanmu': 'rasa',
'merasakankan': 'rasa',
'merasakani': 'rasa',
'memperasakan': 'rasa',
'merasa-rasai': 'rasa',
'rasa-rasanya': 'rasa',
'rasa-rasanyanya': 'rasa',
'pemberat': 'berat',
'pemberatnya': 'berat',
'pemberatan': 'berat',
'berberat': 'berat',
'berberati': 'berat',
'berberatan': 'berat',
'memberati': 'berat',
'keberatan': 'berat',
'keberatannya': 'berat',
'keberatanlah': 'berat',
'pemberatannya': 'berat',
'memperberat': 'berat',
'memperberatnya': 'berat',
'memperberatkan': 'berat',
'memperberatan': 'berat',
'memberatkan': 'berat',
'memberatkannya': 'berat',
'memberatkankannya': 'berat',
'berkeberatan': 'berat',
'pembicara': 'bicara',
'pembicaranya': 'bicara',
'pembicarakan': 'bicara',
'pembicaraan': 'bicara',
'berbicara': 'bicara',
'berbicaranya': 'bicara',
'berbicaralah': 'bicara',
'berbicarakan': 'bicara',
'pembicaraannya': 'bicara',
'pembicaraanku': 'bicara',
'pembicaraanmu': 'bicara',
'membicarakan': 'bicara',
'membicarakannya': 'bicara',
'membicarakankan': 'bicara',
'membicarakanku': 'bicara',
'membicarakanmu': 'bicara',
'bilangan': 'bilang',
'bilangannya': 'bilang',
'bilanganan': 'bilang',
'sebilang': 'bilang',
'membilang': 'bilang',
'terbilang': 'bilang',
'pembilang': 'bilang',
'pembilangan': 'bilang',
'berbilang': 'bilang',
'membilangi': 'bilang',
'kebilangan': 'bilang',
'sebilangan': 'bilang',
'membilangkan': 'bilang',
'berbingkai': 'bingkai',
'membingkai': 'bingkai',
'membingkainya': 'bingkai',
'membingkaikan': 'bingkai',
'berbini': 'bini',
'berbinikan': 'bini',
'bini-binian': 'bini',
'memperbinikan': 'bini',
'bintangan': 'bintang',
'sebintang': 'bintang',
'berbintang': 'bintang',
'berbintangnya': 'bintang',
'membintangi': 'bintang',
'membintanginya': 'bintang',
'perbintangan': 'bintang',
'perbintangannya': 'bintang',
'berbintang-bintang': 'bintang',
'berbintik': 'bintik',
'berbintik-bintik': 'bintik',
'berbisa': 'bisa',
'berbisanya': 'bisa',
'kebisaan': 'bisa',
'kebisaannya': 'bisa',
'sebisanya': 'bisa',
'sebisanyalah': 'bisa',
'bisikan': 'bisik',
'bisikannya': 'bisik',
'berbisik': 'bisik',
'berbisiklah': 'bisik',
'pembisik': 'bisik',
'pembisiknya': 'bisik',
'membisiki': 'bisik',
'membisikinya': 'bisik',
'pembisikan': 'bisik',
'membisikkan': 'bisik',
'membisikkannya': 'bisik',
'berbisik-bisik': 'bisik',
'pembohong': 'bohong',
'pembohongnya': 'bohong',
'pembohongan': 'bohong',
'berbohong': 'bohong',
'berbohonglah': 'bohong',
'berbohongan': 'bohong',
'membohong': 'bohong',
'membohongi': 'bohong',
'membohonginya': 'bohong',
'membohongiku': 'bohong',
'kebohongan': 'bohong',
'kebohongannya': 'bohong',
'membohongkan': 'bohong',
'bohong-bohongan': 'bohong',
'bohong-bohongannya': 'bohong',
'bualan': 'bual',
'bualannya': 'bual',
'membual': 'bual',
'pembual': 'bual',
'pembualan': 'bual',
'berbual': 'bual',
'perbualan': 'bual',
'membualkan': 'bual',
'berbual-bual': 'bual',
'buatan': 'buat',
'buatannya': 'buat',
'buatanku': 'buat',
'buatanmu': 'buat',
'berbuat': 'buat',
'berbuatnya': 'buat',
'berbuatlah': 'buat',
'berbuatan': 'buat',
'pembuat': 'buat',
'pembuatnya': 'buat',
'pembuatan': 'buat',
'terbuat': 'buat',
'terbuatnya': 'buat',
'terbuatlah': 'buat',
'membuat': 'buat',
'membuatnya': 'buat',
'membuatkan': 'buat',
'membuatkannya': 'buat',
'membuati': 'buat',
'membuatan': 'buat',
'membuatku': 'buat',
'membuatmu': 'buat',
'perbuatan': 'buat',
'perbuatannya': 'buat',
'perbuatanku': 'buat',
'perbuatanmu': 'buat',
'teperbuat': 'buat',
'pembuatannya': 'buat',
'pembuatanan': 'buat',
'membuatkanmu': 'buat',
'memperbuat': 'buat',
'buat-buatan': 'buat',
'membuat-buat': 'buat',
'membuat-buatnya': 'buat',
'berbucu': 'bucu',
'sebudi': 'budi',
'berbudi': 'budi',
'memperbudikan': 'budi',
'berbuih': 'buih',
'membuih': 'buih',
'pembuih': 'buih',
'berbukit': 'bukit',
'berbukitan': 'bukit',
'membukit': 'bukit',
'membukitkan': 'bukit',
'perbukitan': 'bukit',
'perbukitannya': 'bukit',
'berbukit-bukit': 'bukit',
'berbukti': 'bukti',
'berbuktian': 'bukti',
'terbukti': 'bukti',
'terbuktinya': 'bukti',
'terbuktilah': 'bukti',
'terbuktikan': 'bukti',
'terbuktii': 'bukti',
'pembuktian': 'bukti',
'pembuktiannya': 'bukti',
'pembuktiani': 'bukti',
'membuktikan': 'bukti',
'membuktikannya': 'bukti',
'bulanan': 'bulan',
'bulanannya': 'bulan',
'bulananlah': 'bulan',
'bulananan': 'bulan',
'bulananmu': 'bulan',
'bulanan-mu': 'bulan',
'berbulan': 'bulan',
'membulan': 'bulan',
'bulan-bulanan': 'bulan',
'bulan-bulanannya': 'bulan',
'bulan-bulananan': 'bulan',
'berbulan-bulan': 'bulan',
'berbulan-bulanlah': 'bulan',
'membulan-bulani': 'bulan',
'berbulu': 'bulu',
'berbulunya': 'bulu',
'membului': 'bulu',
'berbunga': 'bunga',
'membunga': 'bunga',
'membungakan': 'bunga',
'membungai': 'bunga',
'perbungaan': 'bunga',
'bunga-bungaan': 'bunga',
'berbunga-bunga': 'bunga',
'berbunga-bunganya': 'bunga',
'memperbungakan': 'bunga',
'membunga-bungai': 'bunga',
'sebunyi': 'bunyi',
'berbunyi': 'bunyi',
'berbunyinya': 'bunyi',
'berbunyilah': 'bunyi',
'berbunyikan': 'bunyi',
'pembunyian': 'bunyi',
'pembunyiannya': 'bunyi',
'membunyikan': 'bunyi',
'membunyikannya': 'bunyi',
'bunyi-bunyian': 'bunyi',
'buruan': 'buru',
'buruannya': 'buru',
'keburu': 'buru',
'keburukan': 'buru',
'keburukannya': 'buru',
'terburu': 'buru',
'terburuku': 'buru',
'memburu': 'buru',
'memburunya': 'buru',
'memburukan': 'buru',
'memburuku': 'buru',
'memburumu': 'buru',
'pemburu': 'buru',
'pemburunya': 'buru',
'pemburulah': 'buru',
'pemburukan': 'buru',
'pemburuan': 'buru',
'berburu': 'buru',
'berburunya': 'buru',
'berburuan': 'buru',
'perburuan': 'buru',
'perburuannya': 'buru',
'berburu-buru': 'buru',
'terburu-buru': 'buru',
'terburu-burunya': 'buru',
'terburu-burulah': 'buru',
'memburu-buru': 'buru',
'memburu-burukan': 'buru',
'pembusa': 'busa',
'pembusaan': 'busa',
'membusa': 'busa',
'berbusa': 'busa',
'berbusanya': 'busa',
'membusakan': 'busa',
'membutir': 'butir',
'berbutir': 'butir',
'berbutir-butir': 'butir',
'mencabang': 'cabang',
'bercabang': 'cabang',
'bercabangnya': 'cabang',
'bercabanglah': 'cabang',
'pencabangan': 'cabang',
'percabangan': 'cabang',
'percabangannya': 'cabang',
'mencabangkan': 'cabang',
'mempercabangkan': 'cabang',
'bercabang-cabang': 'cabang',
'cacahan': 'cacah',
'cacahannya': 'cacah',
'bercacah': 'cacah',
'pencacah': 'cacah',
'pencacahnya': 'cacah',
'pencacahan': 'cacah',
'mencacah': 'cacah',
'mencacah-cacah': 'cacah',
'bebercak': 'bercak',
'cakapan': 'cakap',
'bercakap': 'cakap',
'bercakapan': 'cakap',
'kecakapan': 'cakap',
'kecakapannya': 'cakap',
'mencakapi': 'cakap',
'percakapan': 'cakap',
'percakapannya': 'cakap',
'percakapanlah': 'cakap',
'percakapanmu': 'cakap',
'mempercakap': 'cakap',
'mempercakapkan': 'cakap',
'bercakap-cakap': 'cakap',
'bercakap-cakaplah': 'cakap',
'tercalar': 'calar',
'bercalar': 'calar',
'calar-balar': 'calar',
'mencalarkan': 'calar',
'bercanggah': 'canggah',
'bercangkuk': 'cangkuk',
'mencangkuk': 'cangkuk',
'tercantum': 'cantum',
'tercantumnya': 'cantum',
'tercantumkan': 'cantum',
'tercantuman': 'cantum',
'mencantum': 'cantum',
'mencantumkan': 'cantum',
'mencantumkannya': 'cantum',
'mencantuman': 'cantum',
'bercantum': 'cantum',
'bercantumkan': 'cantum',
'pencantuman': 'cantum',
'pencantumannya': 'cantum',
'catan': 'cat',
'catani': 'cat',
'catanan': 'cat',
'bercat': 'cat',
'bercatkan': 'cat',
'mengecat': 'cat',
'mengecatnya': 'cat',
'pengecatan': 'cat',
'pengecatannya': 'cat',
'berceloteh': 'celoteh',
'bercendawan': 'cendawan',
'bercengkerama': 'cengkerama',
'bercengkeramalah': 'cengkerama',
'berceracak': 'ceracak',
'mencerai': 'cerai',
'menceraikan': 'cerai',
'menceraikannya': 'cerai',
'menceraiku': 'cerai',
'tercerai': 'cerai',
'bercerai': 'cerai',
'bercerainya': 'cerai',
'berceraian': 'cerai',
'perceraian': 'cerai',
'perceraiannya': 'cerai',
'perceraianmu': 'cerai',
'penceraian': 'cerai',
'penceraiannya': 'cerai',
'bercerai-cerai': 'cerai',
'berceramah': 'ceramah',
'penceramah': 'ceramah',
'penceramahnya': 'ceramah',
'penceramahan': 'ceramah',
'menceramahkan': 'ceramah',
'berceranggah': 'ceranggah',
'ceritaan': 'cerita',
'bercerita': 'cerita',
'berceritalah': 'cerita',
'berceritakan': 'cerita',
'pencerita': 'cerita',
'penceritanya': 'cerita',
'penceritaan': 'cerita',
'menceritai': 'cerita',
'penceritaannya': 'cerita',
'menceritakan': 'cerita',
'menceritakannya': 'cerita',
'menceritakankan': 'cerita',
'bercinta': 'cinta',
'bercintanya': 'cinta',
'bercintalah': 'cinta',
'bercintaku': 'cinta',
'mencinta': 'cinta',
'mencintanya': 'cinta',
'mencintai': 'cinta',
'mencintaku': 'cinta',
'mencintamu': 'cinta',
'tercinta': 'cinta',
'tercintanya': 'cinta',
'tercintaku': 'cinta',
'tercintamu': 'cinta',
'pencinta': 'cinta',
'pencintanya': 'cinta',
'kecintaan': 'cinta',
'kecintaannya': 'cinta',
'kecintaanku': 'cinta',
'kecintaanmu': 'cinta',
'mencintainya': 'cinta',
'mencintaiku': 'cinta',
'mencintaimu': 'cinta',
'mencintai-mu': 'cinta',
'percintaan': 'cinta',
'percintaannya': 'cinta',
'bercintakan': 'cinta',
'mencintakan': 'cinta',
'bercinta-cintaan': 'cinta',
'bercorak': 'corak',
'bercorakkan': 'corak',
'bercorakan': 'corak',
'corak-carik': 'corak',
'tercoreng': 'coreng',
'tercorengnya': 'coreng',
'tercorengkan': 'coreng',
'tercorengi': 'coreng',
'bercoreng': 'coreng',
'mencoreng': 'coreng',
'mencorengnya': 'coreng',
'mencorengkan': 'coreng',
'coreng-moreng': 'coreng',
'coreng-morengnya': 'coreng',
'bercoreng-moreng': 'coreng',
'bercoreng-coreng': 'coreng',
'tercoreng-moreng': 'coreng',
'cucuran': 'cucur',
'mencucuri': 'cucur',
'bercucuran': 'cucur',
'mencucurkan': 'cucur',
'mencukur': 'cukur',
'mencukurnya': 'cukur',
'pencukur': 'cukur',
'pencukurnya': 'cukur',
'pencukuran': 'cukur',
'bercukur': 'cukur',
'bercukurlah': 'cukur',
'bercuti': 'cuti',
'berdada': 'dada',
'mendada': 'dada',
'mendadakan': 'dadak',
'berdada-dadaan': 'dada',
'sedaging': 'daging',
'pedaging': 'daging',
'pedagingnya': 'daging',
'pedagingan': 'daging',
'pendaging': 'daging',
'mendaging': 'daging',
'mendagingku': 'daging',
'terdaging': 'daging',
'berdaging': 'daging',
'daging-dagingan': 'daging',
'mendahak': 'dahak',
'berdahak': 'dahak',
'berdakwah': 'dakwah',
'berdakwahnya': 'dakwah',
'berdakwahlah': 'dakwah',
'pendakwah': 'dakwah',
'mendakwah': 'dakwah',
'mendakwahkan': 'dakwah',
'mendakwahkannya': 'dakwah',
'mendakwahi': 'dakwah',
'mendalih': 'dalih',
'mendalihkan': 'dalih',
'berdalih': 'dalih',
'berdalihnya': 'dalih',
'berdalihkan': 'dalih',
'berdalih-dalih': 'dalih',
'pendamai': 'damai',
'pendamaian': 'damai',
'berdamai': 'damai',
'berdamainya': 'damai',
'berdamailah': 'damai',
'berdamaian': 'damai',
'kedamaian': 'damai',
'kedamaiannya': 'damai',
'kedamaianan': 'damai',
'perdamaian': 'damai',
'perdamaiannya': 'damai',
'perdamaianan': 'damai',
'mendamaikan': 'damai',
'mendamaikannya': 'damai',
'terdamaikan': 'damai',
'memperdamaikan': 'damai',
'berdamping': 'damping',
'berdampingi': 'damping',
'berdampingan': 'damping',
'pendamping': 'damping',
'pendampingnya': 'damping',
'pendampingi': 'damping',
'pendampingan': 'damping',
'pendampingku': 'damping',
'pendampingmu': 'damping',
'kedampingan': 'damping',
'mendampingi': 'damping',
'mendampinginya': 'damping',
'mendampingii': 'damping',
'mendampingiku': 'damping',
'mendampingimu': 'damping',
'pendampingannya': 'damping',
'pendampinganan': 'damping',
'berdampingannya': 'damping',
'mendampingkan': 'damping',
'dandanan': 'dandan',
'dandanannya': 'dandan',
'berdandan': 'dandan',
'berdandannya': 'dandan',
'berdandanlah': 'dandan',
'berdandanan': 'dandan',
'mendandani': 'dandan',
'mendandaninya': 'dandan',
'mendandaniku': 'dandan',
'pedansa': 'dansa',
'berdansa': 'dansa',
'berdansanya': 'dansa',
'berdansalah': 'dansa',
'dansa-dansi': 'dansa',
'berdasar': 'dasar',
'berdasarnya': 'dasar',
'berdasarkan': 'dasar',
'berdasarkannya': 'dasar',
'berdasari': 'dasar',
'berdasaran': 'dasar',
'mendasar': 'dasar',
'mendasarnya': 'dasar',
'mendasarkan': 'dasar',
'mendasarkannya': 'dasar',
'mendasari': 'dasar',
'mendasarinya': 'dasar',
'berdasarkankan': 'dasar',
'mendaulat': 'daulat',
'mendaulatnya': 'daulat',
'mendaulatkan': 'daulat',
'berdaulat': 'daulat',
'berdaulatnya': 'daulat',
'berdaulatan': 'daulat',
'pendaulat': 'daulat',
'pendaulatan': 'daulat',
'kedaulatan': 'daulat',
'kedaulatannya': 'daulat',
'kedaulatanlah': 'daulat',
'pendaulatannya': 'daulat',
'berdaun': 'daun',
'berdaunkan': 'daun',
'mendaun': 'daun',
'dedaunan': 'daun',
'dedaunannya': 'daun',
'daun-daunan': 'daun',
'berdaya': 'daya',
'berdayanya': 'daya',
'berdayakan': 'daya',
'berdayaan': 'daya',
'teperdaya': 'daya',
'perdayaan': 'daya',
'memperdaya': 'daya',
'memperdayanya': 'daya',
'memperdayakan': 'daya',
'memperdayai': 'daya',
'pemberdayaan': 'daya',
'pemberdayaannya': 'daya',
'memberdayakan': 'daya',
'memberdayakannya': 'daya',
'pedayung': 'dayung',
'berdayung': 'dayung',
'mendayung': 'dayung',
'mendayungnya': 'dayung',
'pendayung': 'dayung',
'mendayungkan': 'dayung',
'dayung-mayung': 'dayung',
'debaran': 'debar',
'berdebar': 'debar',
'berdebarnya': 'debar',
'mendebarkan': 'debar',
'mendebarkannya': 'debar',
'berdebar-debar': 'debar',
'berdebu': 'debu',
'mendebu': 'debu',
'berdebuk': 'debuk',
'berdebur': 'debur',
'mendebur': 'debur',
'mendecit': 'decit',
'mendecitkan': 'decit',
'berdecit': 'decit',
'berdecitnya': 'decit',
'berdedikasi': 'dedikasi',
'berdedikasinya': 'dedikasi',
'berdedikasilah': 'dedikasi',
'deklamasian': 'deklamasi',
'berdeklamasi': 'deklamasi',
'pendeklamasian': 'deklamasi',
'mendeklamasikan': 'deklamasi',
'mendemonstrasi': 'demonstrasi',
'mendemonstrasikan': 'demonstrasi',
'mendemonstrasikannya': 'demonstrasi',
'berdemonstrasi': 'demonstrasi',
'mendengking': 'dengking',
'berdengking': 'dengking',
'mendengking-dengking': 'dengking',
'dengking-mendengking': 'dengking',
'dengkuran': 'dengkur',
'dengkurannya': 'dengkur',
'mendengkur': 'dengkur',
'mendengkurnya': 'dengkur',
'berdengkur': 'dengkur',
'dengungan': 'dengung',
'mendengung': 'dengung',
'mendengungnya': 'dengung',
'mendengungkan': 'dengung',
'mendengungkannya': 'dengung',
'berdengung': 'dengung',
'berdengungnya': 'dengung',
'dengusan': 'dengus',
'dengusannya': 'dengus',
'berdengus': 'dengus',
'mendengus': 'dengus',
'mendengus-dengus': 'dengus',
'dentingan': 'denting',
'mendenting': 'denting',
'mendentingkan': 'denting',
'berdenting': 'denting',
'berdentingan': 'denting',
'dentuman': 'dentum',
'dentumannya': 'dentum',
'berdentum': 'dentum',
'berdentuman': 'dentum',
'berdentumanlah': 'dentum',
'berdentum-dentum': 'dentum',
'denyaran': 'denyar',
'berdenyar': 'denyar',
'berdenyar-denyar': 'denyar',
'menderam': 'deram',
'berderam': 'deram',
'berderam-deram': 'deram',
'deretan': 'deret',
'deretannya': 'deret',
'berderet': 'deret',
'berderetan': 'deret',
'menderetkan': 'deret',
'mendering': 'dering',
'menderingkan': 'dering',
'berdering': 'dering',
'berdering-dering': 'dering',
'menderum': 'derum',
'berderum': 'derum',
'menderumkan': 'derum',
'mendesing': 'desing',
'berdesing': 'desing',
'berdesingan': 'desing',
'berdesing-desing': 'desing',
'desiran': 'desir',
'berdesir': 'desir',
'mendesir': 'desir',
'detikan': 'detik',
'mendetik': 'detik',
'berdetik': 'detik',
'detik-detik': 'detik',
'detik-detiknya': 'detik',
'pendiam': 'diam',
'pendiamnya': 'diam',
'pendiamlah': 'diam',
'pendiaman': 'diam',
'berdiam': 'diam',
'berdiamnya': 'diam',
'berdiamlah': 'diam',
'terdiam': 'diam',
'terdiamnya': 'diam',
'terdiamlah': 'diam',
'mendiami': 'diam',
'mendiaminya': 'diam',
'mendiamimu': 'diam',
'kediaman': 'diam',
'kediamannya': 'diam',
'kediamanan': 'diam',
'kediamanku': 'diam',
'diam-diam': 'diam',
'diam-diamnya': 'diam',
'diam-diamkan': 'diam',
'diam-diaman': 'diam',
'mendiamkan': 'diam',
'mendiamkannya': 'diam',
'kependiaman': 'diam',
'didiang': 'diang',
'mendiang': 'diang',
'berdiang': 'diang',
'pendiangan': 'diang',
'pendiet': 'diet',
'berdiet': 'diet',
'berdietnya': 'diet',
'pendiri': 'diri',
'pendirinya': 'diri',
'pendirikan': 'diri',
'pendirii': 'diri',
'pendirian': 'diri',
'terdiri': 'diri',
'terdirii': 'diri',
'berdiri': 'diri',
'berdirinya': 'diri',
'berdirilah': 'diri',
'berdirikan': 'diri',
'berdiriku': 'diri',
'pendiriannya': 'diri',
'pendirianku': 'diri',
'pendirianmu': 'diri',
'mendirikan': 'diri',
'mendirikannya': 'diri',
'mendirikankan': 'diri',
'berpendirian': 'diri',
'berpendiriannya': 'diri',
'berdisiplin': 'disiplin',
'berdisiplinlah': 'disiplin',
'mendisiplinkan': 'disiplin',
'mendisiplinkannya': 'disiplin',
'mendoa': 'doa',
'mendoakan': 'doa',
'mendoakannya': 'doa',
'mendoaan': 'doa',
'berdoa': 'doa',
'berdoanya': 'doa',
'berdoalah': 'doa',
'mendoakanlah': 'doa',
'mendoakanku': 'doa',
'mendoakanmu': 'doa',
'berdosa': 'dosa',
'berdosanya': 'dosa',
'berdosalah': 'dosa',
'pendosa': 'dosa',
'seduit': 'duit',
'berduit': 'duit',
'berduitnya': 'duit',
'berduitlah': 'duit',
'berdukacita': 'dukacita',
'berdukacitanya': 'dukacita',
'berdukacitalah': 'dukacita',
'mendukacitakan': 'dukacita',
'berduri': 'duri',
'berdurinya': 'duri',
'menduri': 'duri',
'berduri-duri': 'duri',
'berdusta': 'dusta',
'pendusta': 'dusta',
'pendustaan': 'dusta',
'mendusta': 'dusta',
'mendustakan': 'dusta',
'mendustakannya': 'dusta',
'mendustai': 'dusta',
'mendustainya': 'dusta',
'mereaksi': 'reaksi',
'mereaksinya': 'reaksi',
'mereaksikan': 'reaksi',
'bereaksi': 'reaksi',
'bereaksinya': 'reaksi',
'bereaksilah': 'reaksi',
'pereaksi': 'reaksi',
'memberedel': 'beredel',
'memberedelnya': 'beredel',
'beregu': 'regu',
'embunan': 'embun',
'berembun': 'embun',
'mengembun': 'embun',
'mengembunkan': 'embun',
'pengembun': 'embun',
'pengembunan': 'embun',
'mengembuni': 'embun',
'pengembunannya': 'embun',
'memperembunkan': 'embun',
'perenang': 'renang',
'perenangnya': 'renang',
'perenangan': 'renang',
'berenang': 'renang',
'berenangnya': 'renang',
'berenanglah': 'renang',
'merenangi': 'renang',
'berenangan': 'renang',
'merenangkan': 'renang',
'merenda': 'renda',
'merendakan': 'renda',
'berenda': 'renda',
'merendai': 'renda',
'keberengsekan': 'berengsek',
'berengsel': 'engsel',
'memberengut': 'berengut',
'memberentang': 'berentang',
'memberentangkan': 'berentang',
'memberesi': 'beres',
'memberesinya': 'beres',
'keberesan': 'beres',
'pemberesan': 'beres',
'pemberesannya': 'beres',
'membereskan': 'beres',
'membereskannya': 'beres',
'berevolusi': 'revolusi',
'berevolusinya': 'revolusi',
'berfalsafah': 'falsafah',
'berfalsafahkan': 'falsafah',
'berfungsi': 'fungsi',
'berfungsinya': 'fungsi',
'berfungsilah': 'fungsi',
'berfungsikan': 'fungsi',
'berfungsii': 'fungsi',
'memfungsikan': 'fungsi',
'memfungsikannya': 'fungsi',
'pegadai': 'gadai',
'pegadainya': 'gadai',
'pegadaian': 'gadai',
'gadaian': 'gadai',
'gadaiannya': 'gadai',
'tergadai': 'gadai',
'tergadailah': 'gadai',
'tergadaikan': 'gadai',
'bergadai': 'gadai',
'menggadai': 'gadai',
'menggadainya': 'gadai',
'menggadaikan': 'gadai',
'menggadaikannya': 'gadai',
'pegadaiannya': 'gadai',
'penggadai': 'gadai',
'penggadaian': 'gadai',
'bergaduh': 'gaduh',
'penggaduh': 'gaduh',
'menggaduh': 'gaduh',
'menggaduhkan': 'gaduh',
'kegaduhan': 'gaduh',
'kegaduhannya': 'gaduh',
'pergaduhan': 'gaduh',
'penggaduhan': 'gaduh',
'gambaran': 'gambar',
'gambarannya': 'gambar',
'gambaranku': 'gambar',
'tergambar': 'gambar',
'tergambarnya': 'gambar',
'tergambarlah': 'gambar',
'tergambarkan': 'gambar',
'bergambar': 'gambar',
'bergambarnya': 'gambar',
'bergambarkan': 'gambar',
'menggambar': 'gambar',
'menggambarnya': 'gambar',
'menggambarkan': 'gambar',
'menggambarkannya': 'gambar',
'menggambari': 'gambar',
'menggambaran': 'gambar',
'penggambar': 'gambar',
'penggambarnya': 'gambar',
'penggambarkan': 'gambar',
'penggambaran': 'gambar',
'menggambarinya': 'gambar',
'penggambarannya': 'gambar',
'menggambarkankan': 'gambar',
'menggambarkanmu': 'gambar',
'gambar-menggambar': 'gambar',
'berganda': 'ganda',
'bergandanya': 'ganda',
'mengganda': 'ganda',
'menggandakan': 'ganda',
'menggandakannya': 'ganda',
'menggandaan': 'ganda',
'pergandaan': 'ganda',
'penggandaan': 'ganda',
'penggandaannya': 'ganda',
'mempergandakan': 'ganda',
'berganda-ganda': 'ganda',
'ganda-berganda': 'ganda',
'memperganda-gandakan': 'ganda',
'berganding': 'ganding',
'bergandingan': 'ganding',
'mempergandingkan': 'ganding',
'terganjak': 'ganjak',
'berganjak': 'ganjak',
'mengganjak': 'ganjak',
'mengganjakkan': 'ganjak',
'berganti': 'ganti',
'bergantinya': 'ganti',
'bergantilah': 'ganti',
'bergantikan': 'ganti',
'bergantian': 'ganti',
'mengganti': 'ganti',
'menggantinya': 'ganti',
'menggantikan': 'ganti',
'menggantikannya': 'ganti',
'menggantii': 'ganti',
'menggantian': 'ganti',
'menggantiku': 'ganti',
'menggantimu': 'ganti',
'pengganti': 'ganti',
'penggantinya': 'ganti',
'penggantikan': 'ganti',
'penggantian': 'ganti',
'penggantinyalah': 'ganti',
'penggantiku': 'ganti',
'penggantimu': 'ganti',
'pergantian': 'ganti',
'pergantiannya': 'ganti',
'penggantiannya': 'ganti',
'menggantikanku': 'ganti',
'berganti-ganti': 'ganti',
'berganti-gantinya': 'ganti',
'berganti-gantian': 'ganti',
'gantungan': 'gantung',
'gantungannya': 'gantung',
'bergantung': 'gantung',
'bergantungnya': 'gantung',
'bergantunglah': 'gantung',
'bergantungkan': 'gantung',
'bergantungan': 'gantung',
'tergantung': 'gantung',
'tergantungnya': 'gantung',
'tergantunglah': 'gantung',
'tergantungan': 'gantung',
'menggantung': 'gantung',
'menggantungnya': 'gantung',
'menggantunglah': 'gantung',
'menggantungkan': 'gantung',
'menggantungkannya': 'gantung',
'menggantungi': 'gantung',
'menggantungan': 'gantung',
'menggantungmu': 'gantung',
'pergantungan': 'gantung',
'penggantungan': 'gantung',
'ketergantungan': 'gantung',
'ketergantungannya': 'gantung',
'mempergantungi': 'gantung',
'bergaul': 'gaul',
'bergaulnya': 'gaul',
'bergaullah': 'gaul',
'bergaulan': 'gaul',
'menggaul': 'gaul',
'menggauli': 'gaul',
'menggaulinya': 'gaul',
'pergaulan': 'gaul',
'pergaulannya': 'gaul',
'pergaulanmu': 'gaul',
'mempergauli': 'gaul',
'menggaulkan': 'gaul',
'mempergaulkan': 'gaul',
'bergaung': 'gaung',
'bergaungnya': 'gaung',
'bergaunglah': 'gaung',
'menggaung': 'gaung',
'menggaungnya': 'gaung',
'menggaungkan': 'gaung',
'menggaungkannya': 'gaung',
'bergaya': 'gaya',
'bergayanya': 'gaya',
'bergayalah': 'gaya',
'menggaya': 'gaya',
'menggayakan': 'gaya',
'gaya-gayanya': 'gaya',
'bergaya-gaya': 'gaya',
'bergaya-gayaan': 'gaya',
'gayutan': 'gayut',
'bergayut': 'gayut',
'penggayut': 'gayut',
'menggayuti': 'gayut',
'bergayutan': 'gayut',
'menggayutkan': 'gayut',
'tergegar': 'gegar',
'bergegar': 'gegar',
'menggegar': 'gegar',
'menggegarkan': 'gegar',
'tergegas': 'gegas',
'bergegas': 'gegas',
'bergegasnya': 'gegas',
'bergegaslah': 'gegas',
'menggegas': 'gegas',
'menggegaskan': 'gegas',
'penggegasan': 'gegas',
'mempergegas': 'gegas',
'tergegas-gegas': 'gegas',
'bergegas-gegas': 'gegas',
'bergejolak': 'gejolak',
'bergejolaknya': 'gejolak',
'menggejolak': 'gejolak',
'bergelar': 'gelar',
'bergelarnya': 'gelar',
'menggelar': 'gelar',
'menggelarnya': 'gelar',
'menggelarkan': 'gelar',
'menggelari': 'gelar',
'menggelaran': 'gelar',
'pegelaran': 'gelar',
'pergelaran': 'gelar',
'pergelarannya': 'gelar',
'menggelarinya': 'gelar',
'mempergelarkan': 'gelar',
'bergelimpang': 'gelimpang',
'bergelimpangnya': 'gelimpang',
'bergelimpangan': 'gelimpang',
'tergelimpang': 'gelimpang',
'bergelombang': 'gelombang',
'bergelombangnya': 'gelombang',
'menggelombang': 'gelombang',
'menggelombangkan': 'gelombang',
'bergelora': 'gelora',
'bergeloranya': 'gelora',
'menggelora': 'gelora',
'menggeloranya': 'gelora',
'menggelorakan': 'gelora',
'menggelorakannya': 'gelora',
'gelungan': 'gelung',
'bergelung': 'gelung',
'menggelung': 'gelung',
'menggelungnya': 'gelung',
'menggelungkan': 'gelung',
'tergelung-gelung': 'gelung',
'gelutan': 'gelut',
'bergelut': 'gelut',
'menggelut': 'gelut',
'menggeluti': 'gelut',
'menggelutinya': 'gelut',
'bergema': 'gema',
'bergemanya': 'gema',
'bergemalah': 'gema',
'menggema': 'gema',
'menggemanya': 'gema',
'menggemalah': 'gema',
'menggemakan': 'gema',
'menggemakannya': 'gema',
'menggemai': 'gema',
'bergembira': 'gembira',
'bergembiranya': 'gembira',
'bergembiralah': 'gembira',
'kegembiraan': 'gembira',
'kegembiraannya': 'gembira',
'kegembiraanku': 'gembira',
'penggembira': 'gembira',
'penggembiranya': 'gembira',
'menggembirakan': 'gembira',
'menggembirakannya': 'gembira',
'menggembirakanlah': 'gembira',
'mempergembirakan': 'gembira',
'bergemuruh': 'gemuruh',
'bergemuruhnya': 'gemuruh',
'bergemuruhlah': 'gemuruh',
'kegemuruhan': 'gemuruh',
'menggemuruh': 'gemuruh',
'menggemuruhkan': 'gemuruh',
'tergenang': 'genang',
'tergenangnya': 'genang',
'tergenangi': 'genang',
'tergenangan': 'genang',
'bergenang': 'genang',
'kegenangan': 'genang',
'menggenang': 'genang',
'menggenangnya': 'genang',
'menggenangkan': 'genang',
'menggenangi': 'genang',
'menggenangan': 'genang',
'menggenanginya': 'genang',
'menggenangii': 'genang',
'penggenangan': 'genang',
'penggenangannya': 'genang',
'segendang': 'gendang',
'gendangan': 'gendang',
'bergendang': 'gendang',
'gendang-gendang': 'gendang',
'gerakan': 'gerak',
'gerakannya': 'gerak',
'gerakanlah': 'gerak',
'gerakani': 'gerak',
'gerakanan': 'gerak',
'gerakanku': 'gerak',
'gerakanmu': 'gerak',
'bergerak': 'gerak',
'bergeraknya': 'gerak',
'bergeraklah': 'gerak',
'bergeraki': 'gerak',
'bergerakan': 'gerak',
'tergerak': 'gerak',
'tergeraknya': 'gerak',
'tergeraklah': 'gerak',
'tergerakkan': 'gerak',
'tergerakan': 'gerak',
'penggerak': 'gerak',
'penggeraknya': 'gerak',
'penggerakkan': 'gerak',
'penggerakan': 'gerak',
'pergerakan': 'gerak',
'pergerakannya': 'gerak',
'pergerakanan': 'gerak',
'pergerakanku': 'gerak',
'pergerakanmu': 'gerak',
'penggerakannya': 'gerak',
'menggerakkan': 'gerak',
'menggerakkannya': 'gerak',
'menggerakkanku': 'gerak',
'menggerak-gerakkan': 'gerak',
'menggerak-gerakkanku': 'gerak',
'bergerigi': 'gerigi',
'bergerincing': 'gerincing',
'gesekan': 'gesek',
'gesekannya': 'gesek',
'bergesek': 'gesek',
'bergesekkan': 'gesek',
'bergesekan': 'gesek',
'menggesek': 'gesek',
'menggeseknya': 'gesek',
'menggesekkan': 'gesek',
'menggesekkannya': 'gesek',
'menggesekan': 'gesek',
'penggesek': 'gesek',
'penggeseknya': 'gesek',
'penggesekan': 'gesek',
'pergesekan': 'gesek',
'pergesekannya': 'gesek',
'mempergesekkan': 'gesek',
'bergesel': 'gesel',
'menggesel': 'gesel',
'geseran': 'geser',
'bergeser': 'geser',
'bergesernya': 'geser',
'bergeserlah': 'geser',
'bergeseran': 'geser',
'menggeser': 'geser',
'menggesernya': 'geser',
'menggeserkan': 'geser',
'pergeseran': 'geser',
'pergeserannya': 'geser',
'penggeseran': 'geser',
'penggeserannya': 'geser',
'tergetah': 'getah',
'bergetah': 'getah',
'menggetah': 'getah',
'pergetahan': 'getah',
'penggetahan': 'getah',
'getaran': 'getar',
'getarannya': 'getar',
'bergetar': 'getar',
'bergetarnya': 'getar',
'bergetarlah': 'getar',
'penggetar': 'getar',
'penggetarnya': 'getar',
'penggetaran': 'getar',
'menggetar': 'getar',
'menggetarkan': 'getar',
'menggetarkannya': 'getar',
'bergigi': 'gigi',
'bergiginya': 'gigi',
'pergigian': 'gigi',
'golakan': 'golak',
'bergolak': 'golak',
'bergolaknya': 'golak',
'pergolakan': 'golak',
'pergolakannya': 'golak',
'bergolak-golak': 'golak',
'bergolek': 'golek',
'tergolek': 'golek',
'tergoleknya': 'golek',
'menggolek': 'golek',
'bergolekan': 'golek',
'menggolekkan': 'golek',
'bergolek-golek': 'golek',
'tergolek-golek': 'golek',
'goresan': 'gores',
'goresannya': 'gores',
'bergores': 'gores',
'bergoreskan': 'gores',
'tergores': 'gores',
'tergoresnya': 'gores',
'menggores': 'gores',
'menggoresnya': 'gores',
'menggoreskan': 'gores',
'menggoreskannya': 'gores',
'penggores': 'gores',
'penggoresan': 'gores',
'bergores-gores': 'gores',
'tergoyang': 'goyang',
'tergoyangnya': 'goyang',
'tergoyangkan': 'goyang',
'bergoyang': 'goyang',
'bergoyangnya': 'goyang',
'bergoyanglah': 'goyang',
'kegoyangan': 'goyang',
'menggoyang': 'goyang',
'menggoyangnya': 'goyang',
'menggoyangkan': 'goyang',
'menggoyangkannya': 'goyang',
'bergoyang-goyang': 'goyang',
'menggoyang-goyangkan': 'goyang',
'menggoyang-goyangkannya': 'goyang',
'berguling': 'guling',
'bergulingnya': 'guling',
'bergulinglah': 'guling',
'bergulingan': 'guling',
'terguling': 'guling',
'tergulingnya': 'guling',
'tergulingkan': 'guling',
'mengguling': 'guling',
'menggulingkan': 'guling',
'menggulingkannya': 'guling',
'menggulingan': 'guling',
'terguling-guling': 'guling',
'bergumam': 'gumam',
'menggumam': 'gumam',
'menggumamkan': 'gumam',
'gumpalan': 'gumpal',
'gumpalannya': 'gumpal',
'bergumpal': 'gumpal',
'bergumpalan': 'gumpal',
'menggumpal': 'gumpal',
'menggumpalnya': 'gumpal',
'menggumpalkan': 'gumpal',
'penggumpalan': 'gumpal',
'penggumpalannya': 'gumpal',
'bergumpal-gumpal': 'gumpal',
'bergumpal-gumpalan': 'gumpal',
'seguna': 'guna',
'berguna': 'guna',
'bergunanya': 'guna',
'pengguna': 'guna',
'penggunanya': 'guna',
'penggunalah': 'guna',
'penggunakan': 'guna',
'penggunakannya': 'guna',
'penggunai': 'guna',
'penggunaan': 'guna',
'kegunaan': 'guna',
'kegunaannya': 'guna',
'guna-guna': 'guna',
'guna-gunalah': 'guna',
'penggunaannya': 'guna',
'penggunaanan': 'guna',
'guna-ganah': 'guna',
'menggunakan': 'guna',
'menggunakannya': 'guna',
'menggunakankan': 'guna',
'menggunakanan': 'guna',
'menggunakanku': 'guna',
'mempergunakan': 'guna',
'mempergunakannya': 'guna',
'gurauan': 'gurau',
'gurauannya': 'gurau',
'bergurau': 'gurau',
'pergurauan': 'gurau',
'mengguraukan': 'gurau',
'memperguraukan': 'gurau',
'bergusti': 'gusti',
'hajatan': 'hajat',
'hajatannya': 'hajat',
'berhajat': 'hajat',
'menghajati': 'hajat',
'menghajatkan': 'hajat',
'berhala': 'hala',
'berhalakan': 'hala',
'menghalakan': 'hala',
'hamburan': 'hambur',
'terhambur': 'hambur',
'terhamburnya': 'hambur',
'terhamburkan': 'hambur',
'terhamburan': 'hambur',
'menghambur': 'hambur',
'menghamburkan': 'hambur',
'menghamburkannya': 'hambur',
'menghamburan': 'hambur',
'menghamburi': 'hambur',
'berhamburan': 'hambur',
'berhamburannya': 'hambur',
'penghamburan': 'hambur',
'menghambur-hamburkan': 'hambur',
'menghambur-hamburkannya': 'hambur',
'berhantu': 'hantu',
'menghantu': 'hantu',
'menghantui': 'hantu',
'menghantuinya': 'hantu',
'menghantuiku': 'hantu',
'menghantuimu': 'hantu',
'berharga': 'harga',
'berharganya': 'harga',
'berhargaan': 'harga',
'berhargaku': 'harga',
'menghargai': 'harga',
'menghargainya': 'harga',
'menghargailah': 'harga',
'menghargaii': 'harga',
'menghargaiku': 'harga',
'menghargaimu': 'harga',
'penghargaan': 'harga',
'penghargaannya': 'harga',
'penghargaanku': 'harga',
'menghargakan': 'harga',
'menghargakannya': 'harga',
'berhasil': 'hasil',
'berhasilnya': 'hasil',
'berhasillah': 'hasil',
'berhasilkan': 'hasil',
'berhasilan': 'hasil',
'penghasil': 'hasil',
'penghasilnya': 'hasil',
'penghasilkan': 'hasil',
'penghasilan': 'hasil',
'penghasilannya': 'hasil',
'penghasilanku': 'hasil',
'penghasilanmu': 'hasil',
'pemberhasil': 'hasil',
'menghasilkan': 'hasil',
'menghasilkannya': 'hasil',
'keberhasilan': 'hasil',
'keberhasilannya': 'hasil',
'keberhasilanlah': 'hasil',
'keberhasilanan': 'hasil',
'keberhasilanku': 'hasil',
'keberhasilanmu': 'hasil',
'terhasrat': 'hasrat',
'berhasrat': 'hasrat',
'berhasratnya': 'hasrat',
'kehasratan': 'hasrat',
'menghasratkan': 'hasrat',
'berhemat': 'hemat',
'berhematlah': 'hemat',
'berhematan': 'hemat',
'menghemat': 'hemat',
'menghematnya': 'hemat',
'menghematlah': 'hemat',
'menghematkan': 'hemat',
'kehematan': 'hemat',
'kehematannya': 'hemat',
'penghematan': 'hemat',
'penghematannya': 'hemat',
'hentian': 'henti',
'terhenti': 'henti',
'terhentinya': 'henti',
'terhentilah': 'henti',
'terhentikan': 'henti',
'berhenti': 'henti',
'berhentinya': 'henti',
'berhentilah': 'henti',
'berhentikan': 'henti',
'berhentikannya': 'henti',
'berhentii': 'henti',
'penghenti': 'henti',
'penghentikan': 'henti',
'penghentikannya': 'henti',
'penghentian': 'henti',
'perhentian': 'henti',
'perhentiannya': 'henti',
'penghentiannya': 'henti',
'menghentikan': 'henti',
'menghentikannya': 'henti',
'menghentikanku': 'henti',
'menghentikanmu': 'henti',
'pemberhentian': 'henti',
'pemberhentiannya': 'henti',
'memberhentikan': 'henti',
'memberhentikannya': 'henti',
'memperhentikan': 'henti',
'hiasan': 'hias',
'hiasannya': 'hias',
'berhias': 'hias',
'berhiaskan': 'hias',
'berhiasi': 'hias',
'berhiasan': 'hias',
'terhias': 'hias',
'menghias': 'hias',
'menghiasnya': 'hias',
'menghiaskan': 'hias',
'menghiasi': 'hias',
'penghias': 'hias',
'penghiasnya': 'hias',
'perhiasan': 'hias',
'perhiasannya': 'hias',
'perhiasanku': 'hias',
'menghiasinya': 'hias',
'memperhiasi': 'hias',
'berhidung': 'hidung',
'menghidung': 'hidung',
'berhipotesis': 'hipotesis',
'menghipotesiskan': 'hipotesis',
'berhormat': 'hormat',
'terhormat': 'hormat',
'terhormatnya': 'hormat',
'terhormatlah': 'hormat',
'menghormat': 'hormat',
'menghormati': 'hormat',
'menghormatan': 'hormat',
'penghormat': 'hormat',
'penghormatan': 'hormat',
'kehormatan': 'hormat',
'kehormatannya': 'hormat',
'kehormatanku': 'hormat',
'kehormatanmu': 'hormat',
'menghormatinya': 'hormat',
'menghormatilah': 'hormat',
'menghormatii': 'hormat',
'menghormatiku': 'hormat',
'menghormatimu': 'hormat',
'penghormatannya': 'hormat',
'berhormat-hormat': 'hormat',
'hormat-menghormati': 'hormat',
'hubungan': 'hubung',
'hubungannya': 'hubung',
'hubunganlah': 'hubung',
'hubungankan': 'hubung',
'hubungannyalah': 'hubung',
'hubunganku': 'hubung',
'hubunganmu': 'hubung',
'berhubung': 'hubung',
'berhubungnya': 'hubung',
'berhubungkan': 'hubung',
'berhubungan': 'hubung',
'penghubung': 'hubung',
'penghubungnya': 'hubung',
'penghubungkan': 'hubung',
'penghubungi': 'hubung',
'penghubungan': 'hubung',
'berhubungannya': 'hubung',
'berhubunganlah': 'hubung',
'berhubunganan': 'hubung',
'perhubungan': 'hubung',
'perhubungannya': 'hubung',
'menghubungi': 'hubung',
'menghubunginya': 'hubung',
'menghubungiku': 'hubung',
'menghubungimu': 'hubung',
'menghubungkan': 'hubung',
'menghubungkannya': 'hubung',
'menghubungkanku': 'hubung',
'memperhubungkan': 'hubung',
'menghubung-hubungkan': 'hubung',
'menghubung-hubungkannya': 'hubung',
'menghubung-hubungkankan': 'hubung',
'hunian': 'huni',
'huniannya': 'huni',
'hunianmu': 'huni',
'berhuni': 'huni',
'berhunikan': 'huni',
'berhunian': 'huni',
'terhuni': 'huni',
'menghuni': 'huni',
'menghuninya': 'huni',
'penghuni': 'huni',
'penghuninya': 'huni',
'penghunian': 'huni',
'penghuniannya': 'huni',
'berpenghuni': 'huni',
'berpenghuninya': 'huni',
'berpenghunikan': 'huni',
'menghunikan': 'huni',
'tahu': 'beri',
'tahunya': 'beri',
'tahulah': 'beri',
'tahukan': 'beri',
'tahukannya': 'beri',
'tahui': 'beri',
'tahuan': 'beri',
'tahuku': 'beri',
'tahumu': 'beri',
'berian': 'beri',
'beriani': 'beri',
'memberi': 'beri',
'memberinya': 'beri',
'memberikan': 'beri',
'memberikannya': 'beri',
'memberian': 'beri',
'memberiku': 'beri',
'memberimu': 'beri',
'pemberi': 'beri',
'pemberinya': 'beri',
'pemberikan': 'beri',
'pemberii': 'beri',
'pemberian': 'beri',
'pemberiannya': 'beri',
'pemberianmu': 'beri',
'memberikankan': 'beri',
'memberikanan': 'beri',
'memberikanku': 'beri',
'memberikanmu': 'beri',
'beri-memberi': 'beri',
'memberi tahu': 'beri',
'pemberitahuan': 'beri',
'pemberitahuannya': 'beri',
'pemberitahuanlah': 'beri',
'memberitahukan': 'beri',
'memberitahukannya': 'beri',
'memberitahukanku': 'beri',
'memberitahukanmu': 'beri',
'ribuan': 'ribu',
'ribuannya': 'ribu',
'ribuanlah': 'ribu',
'ribuanan': 'ribu',
'seribu': 'ribu',
'seribunya': 'ribu',
'seribuan': 'ribu',
'beribu-ribu': 'ribu',
'menyeribu': 'ribu',
'berikhtiar': 'ikhtiar',
'berikhtiarlah': 'ikhtiar',
'mengikhtiarkan': 'ikhtiar',
'mengikhtiarkannya': 'ikhtiar',
'berikrar': 'ikrar',
'berikrarkan': 'ikrar',
'pengikraran': 'ikrar',
'mengikrarkan': 'ikrar',
'ikutan': 'ikut',
'ikutannya': 'ikut',
'ikutanlah': 'ikut',
'berikut': 'ikut',
'berikutnya': 'ikut',
'berikutlah': 'ikut',
'berikutkan': 'ikut',
'berikutkannya': 'ikut',
'berikuti': 'ikut',
'berikutan': 'ikut',
'berikutku': 'ikut',
'terikut': 'ikut',
'terikutkan': 'ikut',
'terikuti': 'ikut',
'pengikut': 'ikut',
'pengikutnya': 'ikut',
'pengikuti': 'ikut',
'pengikutan': 'ikut',
'pengikutku': 'ikut',
'pengikutmu': 'ikut',
'mengikut': 'ikut',
'mengikutnya': 'ikut',
'mengikutkan': 'ikut',
'mengikutkannya': 'ikut',
'mengikuti': 'ikut',
'ikut-ikut': 'ikut',
'ikut-ikutlah': 'ikut',
'ikut-ikutkan': 'ikut',
'ikut-ikutan': 'ikut',
'mengikutinya': 'ikut',
'mengikutikan': 'ikut',
'mengikutii': 'ikut',
'mengikutian': 'ikut',
'mengikutiku': 'ikut',
'mengikutimu': 'ikut',
'memperikut': 'ikut',
'ikut-ikutanlah': 'ikut',
'ikut-ikutanan': 'ikut',
'memperikutkan': 'ikut',
'beriman': 'iman',
'keimanan': 'iman',
'keimanannya': 'iman',
'keimananan': 'iman',
'keimananmu': 'iman',
'mengimani': 'iman',
'mengimaninya': 'iman',
'berimankan': 'iman',
'berimigrasi': 'imigrasi',
'keimigrasian': 'imigrasi',
'keimigrasiannya': 'imigrasi',
'seberinda': 'berinda',
'pemberingas': 'beringas',
'keberingasan': 'beringas',
'keberingasannya': 'beringas',
'berintegrasi': 'integrasi',
'berintegrasinya': 'integrasi',
'berintegrasii': 'integrasi',
'berintegrasian': 'integrasi',
'mengintegrasikan': 'integrasi',
'mengintegrasikannya': 'integrasi',
'berinteraksi': 'interaksi',
'berinteraksinya': 'interaksi',
'berinteraksilah': 'interaksi',
'seirama': 'irama',
'seiramanya': 'irama',
'berirama': 'irama',
'mengiramakan': 'irama',
'seisi': 'isi',
'seisinya': 'isi',
'isian': 'isi',
'isiannya': 'isi',
'isianlah': 'isi',
'terisi': 'isi',
'terisinya': 'isi',
'terisikan': 'isi',
'berisi': 'isi',
'berisinya': 'isi',
'berisikan': 'isi',
'pengisi': 'isi',
'pengisinya': 'isi',
'pengisikan': 'isi',
'pengisian': 'isi',
'mengisi': 'isi',
'mengisinya': 'isi',
'mengisikan': 'isi',
'mengisikannya': 'isi',
'mengisii': 'isi',
'mengisian': 'isi',
'pengisiannya': 'isi',
'berberita': 'berita',
'pemberita': 'berita',
'pemberitakan': 'berita',
'pemberitaan': 'berita',
'pemberitaannya': 'berita',
'memberitakan': 'berita',
'memberitakannya': 'berita',
'penjaja': 'jaja',
'penjajakan': 'jaja',
'penjajakannya': 'jaja',
'penjajaan': 'jaja',
'menjaja': 'jaja',
'menjajakan': 'jaja',
'menjajakannya': 'jaja',
'berjaja': 'jaja',
'jaja-jajaan': 'jaja',
'jajaran': 'jajar',
'jajarannya': 'jajar',
'sejajar': 'jajar',
'sejajarnya': 'jajar',
'sejajarlah': 'jajar',
'sejajarkan': 'jajar',
'sejajaran': 'jajar',
'menjajar': 'jajar',
'menjajarkan': 'jajar',
'menjajarkannya': 'jajar',
'menjajari': 'jajar',
'menjajaran': 'jajar',
'terjajar': 'jajar',
'berjajar': 'jajar',
'berjajarnya': 'jajar',
'berjajaran': 'jajar',
'pejajaran': 'jajar',
'penjajaran': 'jajar',
'persejajaran': 'jajar',
'menyejajarkan': 'jajar',
'menyejajarkannya': 'jajar',
'sejalan': 'jalan',
'sejalannya': 'jalan',
'sejalankan': 'jalan',
'jalanan': 'jalan',
'jalanannya': 'jalan',
'jalananlah': 'jalan',
'jalananan': 'jalan',
'jalananmu': 'jalan',
'pejalan': 'jalan',
'pejalanan': 'jalan',
'berjalan': 'jalan',
'berjalannya': 'jalan',
'berjalanlah': 'jalan',
'berjalankan': 'jalan',
'berjalanan': 'jalan',
'berjalanku': 'jalan',
'menjalani': 'jalan',
'menjalaninya': 'jalan',
'menjalanikan': 'jalan',
'menjalanii': 'jalan',
'perjalanan': 'jalan',
'perjalanannya': 'jalan',
'perjalananlah': 'jalan',
'perjalananan': 'jalan',
'perjalananku': 'jalan',
'perjalananmu': 'jalan',
'kesejalanan': 'jalan',
'menjalankan': 'jalan',
'menjalankannya': 'jalan',
'menjalankankan': 'jalan',
'menjalankanan': 'jalan',
'berjalan-jalan': 'jalan',
'berjalan-jalannya': 'jalan',
'berjalan-jalanlah': 'jalan',
'jalinan': 'jalin',
'jalinannya': 'jalin',
'berjalin': 'jalin',
'berjalinan': 'jalin',
'menjalin': 'jalin',
'menjalinnya': 'jalin',
'menjalinkan': 'jalin',
'menjalinkannya': 'jalin',
'menjalini': 'jalin',
'menjalinan': 'jalin',
'terjalin': 'jalin',
'terjalinnya': 'jalin',
'terjalinlah': 'jalin',
'terjalinkan': 'jalin',
'terjalinan': 'jalin',
'penjalinan': 'jalin',
'jalin-berjalin': 'jalin',
'berjalin-jalin': 'jalin',
'jalin-menjalin': 'jalin',
'jamuan': 'jamu',
'jamuannya': 'jamu',
'berjamu': 'jamu',
'menjamu': 'jamu',
'menjamunya': 'jamu',
'menjamui': 'jamu',
'perjamuan': 'jamu',
'perjamuannya': 'jamu',
'penjamuan': 'jamu',
'memperjamu': 'jamu',
'menjamukan': 'jamu',
'jangkitan': 'jangkit',
'menjangkit': 'jangkit',
'menjangkitnya': 'jangkit',
'menjangkiti': 'jangkit',
'berjangkit': 'jangkit',
'berjangkitnya': 'jangkit',
'kejangkitan': 'jangkit',
'terjangkiti': 'jangkit',
'terjangkitinya': 'jangkit',
'berjangkitan': 'jangkit',
'penjangkitan': 'jangkit',
'menjangkitkan': 'jangkit',
'jongkat-jangkit': 'jangkit',
'berjanji': 'janji',
'berjanjinya': 'janji',
'berjanjilah': 'janji',
'berjanjii': 'janji',
'berjanjian': 'janji',
'perjanjian': 'janji',
'perjanjiannya': 'janji',
'perjanjianan': 'janji',
'menjanjikan': 'janji',
'menjanjikannya': 'janji',
'menjanjikanlah': 'janji',
'menjanjikanku': 'janji',
'menjanjikanmu': 'janji',
'menjarak': 'jarak',
'menjarakkan': 'jarak',
'menjarakan': 'jarak',
'berjarak': 'jarak',
'berjarakan': 'jarak',
'terjarak': 'jarak',
'menjaraki': 'jarak',
'berjaya': 'jaya',
'berjayanya': 'jaya',
'berjayalah': 'jaya',
'kejayaan': 'jaya',
'kejayaannya': 'jaya',
'menjayakan': 'jaya',
'keberjayaan': 'jaya',
'berjeda': 'jeda',
'terjela': 'jela',
'berjela': 'jela',
'berjela-jela': 'jela',
'jemuran': 'jemur',
'jemurannya': 'jemur',
'menjemur': 'jemur',
'menjemurnya': 'jemur',
'menjemurkan': 'jemur',
'berjemur': 'jemur',
'berjemurnya': 'jemur',
'berjemurlah': 'jemur',
'terjemur': 'jemur',
'penjemuran': 'jemur',
'penjemurannya': 'jemur',
'berjenaka': 'jenaka',
'kejenakaan': 'jenaka',
'kejenakaannya': 'jenaka',
'menjengket': 'jengket',
'berjengket': 'jengket',
'bersijengket': 'jengket',
'bersejengket': 'jengket',
'jerawatan': 'jerawat',
'berjerawat': 'jerawat',
'berjimat': 'jimat',
'berjiran': 'jiran',
'jualan': 'jual',
'jualannya': 'jual',
'jualanlah': 'jual',
'jualanan': 'jual',
'jualanku': 'jual',
'dijual': 'jual',
'dijualnya': 'jual',
'dijuallah': 'jual',
'dijualkan': 'jual',
'dijualkannya': 'jual',
'dijuali': 'jual',
'dijualan': 'jual',
'menjual': 'jual',
'menjualnya': 'jual',
'menjualkan': 'jual',
'menjualkannya': 'jual',
'menjuali': 'jual',
'menjualan': 'jual',
'menjualku': 'jual',
'menjualmu': 'jual',
'terjual': 'jual',
'terjualnya': 'jual',
'terjuallah': 'jual',
'terjualan': 'jual',
'penjual': 'jual',
'penjualnya': 'jual',
'penjualkan': 'jual',
'penjualan': 'jual',
'berjual': 'jual',
'berjualan': 'jual',
'penjualannya': 'jual',
'penjualankan': 'jual',
'penjualanan': 'jual',
'penjualanku': 'jual',
'penjualanmu': 'jual',
'berjualannya': 'jual',
'berjualanan': 'jual',
'dijuang': 'juang',
'dijuangkan': 'juang',
'pejuang': 'juang',
'pejuangnya': 'juang',
'pejuangan': 'juang',
'berjuang': 'juang',
'berjuangnya': 'juang',
'berjuanglah': 'juang',
'berjuangkan': 'juang',
'berjuangan': 'juang',
'kejuangan': 'juang',
'kejuangannya': 'juang',
'perjuangan': 'juang',
'perjuangannya': 'juang',
'perjuanganlah': 'juang',
'perjuangankan': 'juang',
'perjuanganan': 'juang',
'perjuanganku': 'juang',
'perjuanganmu': 'juang',
'kepejuangan': 'juang',
'memperjuangkan': 'juang',
'memperjuangkannya': 'juang',
'pejudi': 'judi',
'berjudi': 'judi',
'berjudinya': 'judi',
'perjudian': 'judi',
'perjudiannya': 'judi',
'penjudian': 'judi',
'menjudikan': 'judi',
'memperjudikan': 'judi',
'berjujuh': 'jujuh',
'menjujuh': 'jujuh',
'berjumbai': 'jumbai',
'menjumbai': 'jumbai',
'terjumbai': 'jumbai',
'berjumbaian': 'jumbai',
'jumbai-jumbai': 'jumbai',
'berjumbai-jumbai': 'jumbai',
'terjuntai': 'juntai',
'menjuntai': 'juntai',
'menjuntainya': 'juntai',
'menjuntaikan': 'juntai',
'berjuntai': 'juntai',
'berjuntaian': 'juntai',
'penjuntaian': 'juntai',
'berjuntai-juntai': 'juntai',
'terjurai': 'jurai',
'berjurai': 'jurai',
'berjuraian': 'jurai',
'jurai-jurai': 'jurai',
'berjurai-jurai': 'jurai',
'mengabung': 'kabung',
'mengabungkan': 'kabung',
'mengabungkannya': 'kabung',
'berkabung': 'kabung',
'berkabungnya': 'kabung',
'berkabungmu': 'kabung',
'perkabungan': 'kabung',
'perkabungannya': 'kabung',
'mengabung-ngabung': 'kabung',
'pengabut': 'kabut',
'pengabutan': 'kabut',
'berkabut': 'kabut',
'mengabutkan': 'kabut',
'mengaki': 'kaki',
'mengakikan': 'kaki',
'berkaki': 'kaki',
'berkala': 'kala',
'berkalanya': 'kala',
'berkala-kala': 'kala',
'berkaliber': 'kaliber',
'berkanji': 'kanji',
'kaparan': 'kapar',
'berkapar': 'kapar',
'terkapar': 'kapar',
'terkaparnya': 'kapar',
'berkaparan': 'kapar',
'mengaparkan': 'kapar',
'karatan': 'karat',
'berkarat': 'karat',
'berkaratnya': 'karat',
'berkasan': 'berkas',
'memberkas': 'berkas',
'memberkaskan': 'berkas',
'terberkas': 'berkas',
'pemberkas': 'berkas',
'pemberkasan': 'berkas',
'pemberkasannya': 'berkas',
'memberkati': 'berkat',
'memberkatinya': 'berkat',
'memberkatiku': 'berkat',
'memberkatimu': 'berkat',
'keberkatan': 'berkat',
'pemberkatan': 'berkat',
'pemberkatannya': 'berkat',
'mengata': 'kata',
'mengatakannya': 'kata',
'mengatai': 'kata',
'mengataan': 'kata',
'mengataku': 'kata',
'berkata': 'kata',
'berkatalah': 'kata',
'mengatainya': 'kata',
'mengataikan': 'kata',
'mengataian': 'kata',
'perkataan': 'kata',
'perkataannya': 'kata',
'perkataanku': 'kata',
'perkataanmu': 'kata',
'terkatakan': 'kata',
'mengatakankan': 'kata',
'mengatakani': 'kata',
'mengatakanan': 'kata',
'mengatakanku': 'kata',
'berkata-kata': 'kata',
'memperkatakan': 'kata',
'mengata-ngatai': 'kata',
'mengata-ngatainya': 'kata',
'kawanan': 'kawan',
'kawanannya': 'kawan',
'kawananan': 'kawan',
'berkawan': 'kawan',
'berkawanan': 'kawan',
'perkawanan': 'kawan',
'perkawanannya': 'kawan',
'berkayuh': 'kayuh',
'mengayuh': 'kayuh',
'mengayuhnya': 'kayuh',
'mengayuhlah': 'kayuh',
'mengayuhkan': 'kayuh',
'pengayuh': 'kayuh',
'pengayuhnya': 'kayuh',
'terkayuhkan': 'kayuh',
'pekebun': 'kebun',
'pekebunan': 'kebun',
'berkebun': 'kebun',
'berkebunnya': 'kebun',
'berkebunan': 'kebun',
'perkebunan': 'kebun',
'perkebunannya': 'kebun',
'perkebunanlah': 'kebun',
'perkebunanan': 'kebun',
'memperkebuni': 'kebun',
'memperkebunkan': 'kebun',
'berkecai': 'kecai',
'terkecai': 'kecai',
'berkecai-kecai': 'kecai',
'pengecambah': 'kecambah',
'pengecambahan': 'kecambah',
'berkecambah': 'kecambah',
'berkecambahnya': 'kecambah',
'perkecambahan': 'kecambah',
'mengecambahkan': 'kecambah',
'berkecamuk': 'kecamuk',
'berkecamuknya': 'kecamuk',
'berkecimpung': 'kecimpung',
'berkecimpungnya': 'kecimpung',
'kedaian': 'kedai',
'pekedai': 'kedai',
'berkedai': 'kedai',
'terkedai': 'kedai',
'perkedaian': 'kedai',
'mengedaikan': 'kedai',
'memperkedaikan': 'kedai',
'kedutan': 'kedut',
'kedutannya': 'kedut',
'kedutanan': 'kedut',
'berkedut': 'kedut',
'berkedutan': 'kedut',
'mengedut': 'kedut',
'mengedutkan': 'kedut',
'kekekalan': 'kekal',
'berkekalan': 'kekal',
'mengekalkan': 'kekal',
'mengekalkannya': 'kekal',
'berkeladak': 'keladak',
'berkelahi': 'kelahi',
'berkelahinya': 'kelahi',
'berkelahian': 'kelahi',
'perkelahian': 'kelahi',
'perkelahiannya': 'kelahi',
'memperkelahikan': 'kelahi',
'berkelakar': 'kelakar',
'berkelana': 'kelana',
'berkelananya': 'kelana',
'pengelana': 'kelana',
'pengelanaan': 'kelana',
'mengelana': 'kelana',
'sekeliling': 'keliling',
'sekelilingnya': 'keliling',
'sekelilingku': 'keliling',
'sekelilingmu': 'keliling',
'berkeliling': 'keliling',
'berkelilingnya': 'keliling',
'berkelilinglah': 'keliling',
'berkelilingi': 'keliling',
'pengeliling': 'keliling',
'pengelilingan': 'keliling',
'mengelilingi': 'keliling',
'mengelilinginya': 'keliling',
'mengelilingiku': 'keliling',
'mengelilingimu': 'keliling',
'mengelilingkan': 'keliling',
'berkelok': 'kelok',
'mengelok': 'kelok',
'mengelokkan': 'kelok',
'berkelok-kelok': 'kelok',
'berkelok-keloknya': 'kelok',
'berkelopak': 'kelopak',
'terkelopak': 'kelopak',
'mengelopak': 'kelopak',
'berkeluarga': 'keluarga',
'kekeluargaan': 'keluarga',
'kekeluargaannya': 'keluarga',
'kekeluargaanlah': 'keluarga',
'perkeluargaan': 'keluarga',
'kemasan': 'kemas',
'kemasannya': 'kemas',
'kemasanlah': 'kemas',
'kemasani': 'kemas',
'kemasanan': 'kemas',
'berkemas': 'kemas',
'berkemasan': 'kemas',
'pengemas': 'kemas',
'pengemasnya': 'kemas',
'pengemasan': 'kemas',
'mengemas': 'kemas',
'mengemasnya': 'kemas',
'mengemaskan': 'kemas',
'mengemaskannya': 'kemas',
'mengemasi': 'kemas',
'mengemasinya': 'kemas',
'perkemasan': 'kemas',
'pengemasannya': 'kemas',
'kembangan': 'kembang',
'kembangannya': 'kembang',
'kembangankan': 'kembang',
'berkembang': 'kembang',
'berkembangnya': 'kembang',
'berkembanglah': 'kembang',
'berkembangkan': 'kembang',
'berkembangan': 'kembang',
'pengembang': 'kembang',
'pengembangnya': 'kembang',
'pengembanglah': 'kembang',
'pengembangkan': 'kembang',
'pengembangkannya': 'kembang',
'pengembangan': 'kembang',
'mengembang': 'kembang',
'mengembangnya': 'kembang',
'mengembangkan': 'kembang',
'mengembangkannya': 'kembang',
'mengembangi': 'kembang',
'mengembangan': 'kembang',
'pengembangannya': 'kembang',
'pengembangankan': 'kembang',
'pengembanganan': 'kembang',
'perkembangan': 'kembang',
'perkembangannya': 'kembang',
'perkembanganlah': 'kembang',
'perkembanganan': 'kembang',
'perkembangannyalah': 'kembang',
'perkembanganku': 'kembang',
'mengembangkankan': 'kembang',
'memperkembangkan': 'kembang',
'kembaran': 'kembar',
'kembarannya': 'kembar',
'kembaranku': 'kembar',
'berkembar': 'kembar',
'mengembari': 'kembar',
'mengembarkan': 'kembar',
'pengemudi': 'kemudi',
'pengemudinya': 'kemudi',
'pengemudilah': 'kemudi',
'pengemudikan': 'kemudi',
'pengemudian': 'kemudi',
'berkemudi': 'kemudi',
'mengemudikan': 'kemudi',
'mengemudikannya': 'kemudi',
'berkenan': 'kenan',
'berkenannya': 'kenan',
'berkenanan': 'kenan',
'perkenan': 'kenan',
'perkenannya': 'kenan',
'perkenankan': 'kenan',
'perkenanan': 'kenan',
'memperkenankan': 'kenan',
'memperkenankannya': 'kenan',
'terkepak': 'kepak',
'berkepak': 'kepak',
'mengepak': 'pak',
'mengepaknya': 'pak',
'mengepakkan': 'pak',
'mengepakkannya': 'pak',
'mengepaki': 'pak',
'mengepakan': 'pak',
'terkepak-kepak': 'kepak',
'berkepak-kepak': 'kepak',
'mengepak-ngepak': 'kepak',
'mengepak-ngepakkan': 'kepak',
'kepungan': 'kepung',
'kepungannya': 'kepung',
'terkepung': 'kepung',
'terkepungnya': 'kepung',
'pengepung': 'kepung',
'pengepungnya': 'kepung',
'pengepungkan': 'kepung',
'pengepungan': 'kepung',
'berkepung': 'kepung',
'mengepung': 'kepung',
'mengepungnya': 'kepung',
'pengepungannya': 'kepung',
'terkerak': 'kerak',
'terkeraknya': 'kerak',
'berkerak': 'kerak',
'pengeras': 'keras',
'pengerasnya': 'keras',
'pengerasan': 'keras',
'mengeras': 'keras',
'mengerasnya': 'keras',
'mengeraskan': 'keras',
'mengeraskannya': 'keras',
'mengerasi': 'keras',
'mengerasan': 'keras',
'berkeras': 'keras',
'berkerasnya': 'keras',
'berkerasi': 'keras',
'mengerasikannya': 'keras',
'kekerasan': 'keras',
'kekerasannya': 'keras',
'kekerasanlah': 'keras',
'kekerasanan': 'keras',
'bersikeras': 'sikeras',
'bersikerasnya': 'sikeras',
'bersikerasi': 'sikeras',
'memperkeras': 'keras',
'keras-mengerasi': 'keras',
'berkeras-kerasan': 'keras',
'berkeringat': 'keringat',
'berkeringatlah': 'keringat',
'berkeringatan': 'keringat',
'mengeringatkan': 'keringat',
'berkeriut': 'keriut',
'berkeriutan': 'keriut',
'kerumunan': 'kerumun',
'kerumunannya': 'kerumun',
'kerumunanan': 'kerumun',
'sekerumun': 'kerumun',
'sekerumunan': 'kerumun',
'berkerumun': 'kerumun',
'berkerumunnya': 'kerumun',
'berkerumunan': 'kerumun',
'mengerumuni': 'kerumun',
'mengerumuninya': 'kerumun',
'mengerumuniku': 'kerumun',
'mengerut': 'kerut',
'mengerutnya': 'kerut',
'mengerutkan': 'kerut',
'mengerutkannya': 'kerut',
'terkerut': 'kerut',
'berkerut': 'kerut',
'pengerut': 'kerut',
'pengerutan': 'kerut',
'berkerut-kerut': 'kerut',
'bersinambung': 'sinambung',
'bersinambungan': 'sinambung',
'kesinambungan': 'sinambung',
'kesinambungannya': 'sinambung',
'menyinambungkan': 'sinambung',
'berkesinambungan': 'sinambung',
'berkesinambungannya': 'sinambung',
'berkesot': 'kesot',
'mengesot': 'kesot',
'terkesot-kesot': 'kesot',
'berketak': 'ketak',
'berketuk-ketak': 'ketak',
'berketak-ketik': 'ketak',
'berketak-ketak': 'ketak',
'ketukan': 'ketuk',
'ketukannya': 'ketuk',
'pengetuk': 'ketuk',
'pengetukan': 'ketuk',
'terketuk': 'ketuk',
'mengetuk': 'ketuk',
'mengetuknya': 'ketuk',
'mengetukkan': 'ketuk',
'mengetuki': 'ketuk',
'mengetukan': 'ketuk',
'berketuk': 'ketuk',
'berkhasiat': 'khasiat',
'berkhasiatnya': 'khasiat',
'mengkhasiati': 'khasiat',
'berkhidmat': 'khidmat',
'kekhidmatan': 'khidmat',
'kekhidmatannya': 'khidmat',
'kibaran': 'kibar',
'pengibar': 'kibar',
'pengibarnya': 'kibar',
'pengibaran': 'kibar',
'berkibar': 'kibar',
'berkibarnya': 'kibar',
'berkibarlah': 'kibar',
'berkibaran': 'kibar',
'pengibarannya': 'kibar',
'mengibarkan': 'kibar',
'mengibarkannya': 'kibar',
'berkibar-kibar': 'kibar',
'mengibar-ngibarkan': 'kibar',
'mengibar-ngibarkannya': 'kibar',
'kicauan': 'kicau',
'kicauannya': 'kicau',
'kicauanmu': 'kicau',
'berkicau': 'kicau',
'berkicaunya': 'kicau',
'berkicaulah': 'kicau',
'berkicauan': 'kicau',
'kilatan': 'kilat',
'kilatannya': 'kilat',
'mengilat': 'kilat',
'berkilat': 'kilat',
'berkilatan': 'kilat',
'terkilat': 'kilat',
'mengilatkan': 'kilat',
'berkilat-kilat': 'kilat',
'mengilat-ngilatkan': 'kilat',
'kilauan': 'kilau',
'kilauannya': 'kilau',
'mengilau': 'kilau',
'mengilaukan': 'kilau',
'berkilau': 'kilau',
'berkilaunya': 'kilau',
'berkilaulah': 'kilau',
'berkilauan': 'kilau',
'berkilauannya': 'kilau',
'kilau-mengilau': 'kilau',
'berkilau-kilauan': 'kilau',
'kiriman': 'kirim',
'kirimannya': 'kirim',
'kirimanmu': 'kirim',
'terkirim': 'kirim',
'terkirimnya': 'kirim',
'terkirimlah': 'kirim',
'terkirimkan': 'kirim',
'pengirim': 'kirim',
'pengirimnya': 'kirim',
'pengirimkan': 'kirim',
'pengiriman': 'kirim',
'mengirim': 'kirim',
'mengirimnya': 'kirim',
'mengirimkan': 'kirim',
'mengirimkannya': 'kirim',
'mengirimi': 'kirim',
'mengiriman': 'kirim',
'mengirimku': 'kirim',
'mengirimmu': 'kirim',
'berkirim': 'kirim',
'mengiriminya': 'kirim',
'mengirimikan': 'kirim',
'mengirimiku': 'kirim',
'mengirimimu': 'kirim',
'berkiriman': 'kirim',
'perkiriman': 'kirim',
'pengirimannya': 'kirim',
'pengirimanan': 'kirim',
'mengirimkankan': 'kirim',
'mengirimkankannya': 'kirim',
'mengirimkanku': 'kirim',
'mengirimkanmu': 'kirim',
'kirim-berkirim': 'kirim',
'berkirim-kiriman': 'kirim',
'kisaran': 'kisar',
'kisarannya': 'kisar',
'berkisar': 'kisar',
'berkisaran': 'kisar',
'mengisar': 'kisar',
'pengisar': 'kisar',
'pengisaran': 'kisar',
'perkisaran': 'kisar',
'mengisarkan': 'kisar',
'berkisar-kisar': 'kisar',
'sekitar': 'kitar',
'sekitarnya': 'kitar',
'sekitarlah': 'kitar',
'sekitari': 'kitar',
'sekitaran': 'kitar',
'sekitarnyalah': 'kitar',
'sekitarku': 'kitar',
'sekitarmu': 'kitar',
'berkitar': 'kitar',
'mengitar': 'kitar',
'mengitarkan': 'kitar',
'mengitari': 'kitar',
'mengitarinya': 'kitar',
'pengitaran': 'kitar',
'memperkitarkan': 'kitar',
'terkitar-kitar': 'kitar',
'mengitar-ngitar': 'kitar',
'kobaran': 'kobar',
'kobarannya': 'kobar',
'terkobar': 'kobar',
'berkobar': 'kobar',
'berkobarnya': 'kobar',
'berkobarlah': 'kobar',
'berkobaran': 'kobar',
'pengobaran': 'kobar',
'mengobarkan': 'kobar',
'terkobarkan': 'kobar',
'berkobar-kobar': 'kobar',
'berkobar-kobarnya': 'kobar',
'berkocak': 'kocak',
'terkocak': 'kocak',
'mengocak': 'kocak',
'mengocakkan': 'kocak',
'berkocak-kocak': 'kocak',
'berkokok': 'kokok',
'berkokoknya': 'kokok',
'komplotan': 'komplot',
'komplotannya': 'komplot',
'berkomplot': 'komplot',
'berkomplotan': 'komplot',
'berkompromi': 'kompromi',
'berkompromilah': 'kompromi',
'kongsian': 'kongsi',
'berkongsi': 'kongsi',
'perkongsian': 'kongsi',
'perkongsiannya': 'kongsi',
'berkotek': 'kotek',
'berkuasa': 'kuasa',
'berkuasanya': 'kuasa',
'berkuasalah': 'kuasa',
'berkuasai': 'kuasa',
'penguasa': 'kuasa',
'penguasanya': 'kuasa',
'penguasai': 'kuasa',
'penguasaan': 'kuasa',
'kekuasaan': 'kuasa',
'kekuasaannya': 'kuasa',
'kekuasaanlah': 'kuasa',
'kekuasaanku': 'kuasa',
'kekuasaanmu': 'kuasa',
'kekuasaan-ku': 'kuasa',
'kekuasaan-mu': 'kuasa',
'terkuasai': 'kuasa',
'terkuasainya': 'kuasa',
'menguasai': 'kuasa',
'menguasainya': 'kuasa',
'menguasaii': 'kuasa',
'menguasaimu': 'kuasa',
'penguasaannya': 'kuasa',
'sekuasanya': 'kuasa',
'menguasakan': 'kuasa',
'sekuasa-kuasanya': 'kuasa',
'sekuat': 'kuat',
'sekuatnya': 'kuat',
'menguat': 'kuat',
'menguatnya': 'kuat',
'menguatlah': 'kuat',
'menguatkan': 'kuat',
'menguatkannya': 'kuat',
'menguati': 'kuat',
'menguatan': 'kuat',
'berkuat': 'kuat',
'berkuatan': 'kuat',
'penguat': 'kuat',
'penguatnya': 'kuat',
'penguatkan': 'kuat',
'penguatan': 'kuat',
'kekuatan': 'kuat',
'kekuatannya': 'kuat',
'kekuatanan': 'kuat',
'kekuatanku': 'kuat',
'kekuatanmu': 'kuat',
'kekuatan-mu': 'kuat',
'penguatannya': 'kuat',
'penguatanan': 'kuat',
'kuat-kuat': 'kuat',
'kuat-kuatnya': 'kuat',
'kuat-kuatan': 'kuat',
'memperkuat': 'kuat',
'memperkuatnya': 'kuat',
'memperkuatkan': 'kuat',
'memperkuatan': 'kuat',
'berkuat-kuat': 'kuat',
'berkuat-kuatan': 'kuat',
'sekuat-kuatnya': 'kuat',
'berkubah': 'kubah',
'kubangan': 'kubang',
'kubangannya': 'kubang',
'berkubang': 'kubang',
'berkubangnya': 'kubang',
'mengubangkan': 'ubang',
'terkubu': 'kubu',
'berkubu': 'kubu',
'mengubui': 'kubu',
'perkubuan': 'kubu',
'berkuda': 'kuda',
'berkudanya': 'kuda',
'perkudaan': 'kuda',
'memperkuda': 'kuda',
'kuda-kudaan': 'kuda',
'memperkuda-kudakan': 'kuda',
'sekuku': 'kuku',
'berkuku': 'kuku',
'berkulat': 'kulat',
'kulian': 'kuli',
'berkuli': 'kuli',
'menguli': 'uli',
'berkuliah': 'kuliah',
'menguliahi': 'kuliah',
'kumpulan': 'kumpul',
'kumpulannya': 'kumpul',
'terkumpul': 'kumpul',
'terkumpulnya': 'kumpul',
'terkumpullah': 'kumpul',
'terkumpulkan': 'kumpul',
'pengumpul': 'kumpul',
'pengumpulnya': 'kumpul',
'pengumpulkan': 'kumpul',
'pengumpulan': 'kumpul',
'berkumpul': 'kumpul',
'berkumpulnya': 'kumpul',
'berkumpullah': 'kumpul',
'berkumpulkan': 'kumpul',
'berkumpulan': 'kumpul',
'pengumpulannya': 'kumpul',
'pengumpulanan': 'kumpul',
'perkumpulan': 'kumpul',
'perkumpulannya': 'kumpul',
'perkumpulanlah': 'kumpul',
'mengumpulkan': 'kumpul',
'mengumpulkannya': 'kumpul',
'berkumur': 'kumur',
'berkumurlah': 'kumur',
'berkumuran': 'kumur',
'berkumur-kumur': 'kumur',
'kunjungan': 'kunjung',
'kunjungannya': 'kunjung',
'kunjunganku': 'kunjung',
'kunjunganmu': 'kunjung',
'pengunjung': 'kunjung',
'pengunjungnya': 'kunjung',
'pengunjunglah': 'kunjung',
'pengunjungi': 'kunjung',
'pengunjungan': 'kunjung',
'berkunjung': 'kunjung',
'berkunjungnya': 'kunjung',
'berkunjunglah': 'kunjung',
'berkunjungi': 'kunjung',
'berkunjungan': 'kunjung',
'mengunjungi': 'kunjung',
'mengunjunginya': 'kunjung',
'mengunjungii': 'kunjung',
'mengunjungiku': 'kunjung',
'mengunjungimu': 'kunjung',
'berkunjung-kunjungan': 'kunjung',
'pengurang': 'kurang',
'pengurangnya': 'kurang',
'pengurangkan': 'kurang',
'pengurangi': 'kurang',
'pengurangan': 'kurang',
'berkurang': 'kurang',
'berkurangnya': 'kurang',
'berkuranglah': 'kurang',
'berkurangkan': 'kurang',
'berkurangi': 'kurang',
'berkurangan': 'kurang',
'mengurang': 'kurang',
'mengurangnya': 'kurang',
'mengurangkan': 'kurang',
'mengurangkannya': 'kurang',
'mengurangi': 'kurang',
'mengurangan': 'kurang',
'kekurangan': 'kurang',
'kekurangannya': 'kurang',
'kekuranganan': 'kurang',
'kekuranganku': 'kurang',
'kekuranganmu': 'kurang',
'menguranginya': 'kurang',
'mengurangii': 'kurang',
'pengurangannya': 'kurang',
'kurang-kurang': 'kurang',
'kurang-kurangnya': 'kurang',
'kurang-kurangi': 'kurang',
'kurang-kurangan': 'kurang',
'berkekurangan': 'kurang',
'sekurang-kurangnya': 'kurang',
'sekurang-kurangnyanya': 'kurang',
'melabuh': 'labuh',
'melabuhkan': 'labuh',
'melabuhkannya': 'labuh',
'labuhan': 'labuh',
'labuhannya': 'labuh',
'berlabuh': 'labuh',
'berlabuhnya': 'labuh',
'berlabuhan': 'labuh',
'pelabuhan': 'labuh',
'pelabuhannya': 'labuh',
'pelabuhanlah': 'labuh',
'pelabuhanan': 'labuh',
'peladang': 'ladang',
'peladangan': 'ladang',
'berladang': 'ladang',
'berladangnya': 'ladang',
'perladangan': 'ladang',
'perladangannya': 'ladang',
'memperladang': 'ladang',
'memperladangi': 'ladang',
'memperladangkan': 'ladang',
'melaga': 'laga',
'melagakan': 'lagak',
'belaga': 'laga',
'pelaga': 'laga',
'pelagai': 'laga',
'berlaga': 'laga',
'berlaganya': 'laga',
'berlagalah': 'laga',
'berlagai': 'laga',
'perlagaan': 'laga',
'memperlagakan': 'laga',
'melaini': 'lain',
'kelainan': 'lain',
'kelainannya': 'lain',
'kelainanan': 'lain',
'berlainan': 'lain',
'berlainannya': 'lain',
'perlainan': 'lain',
'melainkan': 'lain',
'melainkanan': 'lain',
'memperlain': 'lain',
'berkelainan': 'lain',
'memperlainkan': 'lain',
'berlain-lainan': 'lain',
'lakuan': 'laku',
'selaku': 'laku',
'selakunya': 'laku',
'selakukan': 'laku',
'selakui': 'laku',
'pelaku': 'laku',
'pelakunya': 'laku',
'pelakulah': 'laku',
'pelakukan': 'laku',
'pelakukannya': 'laku',
'pelakui': 'laku',
'pelakuan': 'laku',
'berlaku': 'laku',
'berlakunya': 'laku',
'berlakulah': 'laku',
'berlakukan': 'laku',
'berlakukannya': 'laku',
'berlakui': 'laku',
'berlakuan': 'laku',
'kelakuan': 'laku',
'kelakuannya': 'laku',
'kelakuanku': 'laku',
'kelakuanmu': 'laku',
'perlakuan': 'laku',
'perlakuannya': 'laku',
'perlakuanmu': 'laku',
'melakukan': 'laku',
'melakukannya': 'laku',
'melakukankan': 'laku',
'melakukankannya': 'laku',
'melakukani': 'laku',
'melakukanan': 'laku',
'keberlakuan': 'laku',
'keberlakuannya': 'laku',
'pemberlakuan': 'laku',
'pemberlakuannya': 'laku',
'memberlakukan': 'laku',
'memberlakukannya': 'laku',
'memperlakukan': 'laku',
'memperlakukannya': 'laku',
'memperlakukanku': 'laku',
'memperlakukanmu': 'laku',
'laluan': 'lalu',
'melalui': 'lalu',
'melaluinya': 'lalu',
'melaluii': 'lalu',
'berlalu': 'lalu',
'berlalunya': 'lalu',
'berlalulah': 'lalu',
'berlalukan': 'lalu',
'berlaluan': 'lalu',
'terlalu': 'lalu',
'terlalulah': 'lalu',
'terlalui': 'lalu',
'kelaluan': 'lalu',
'melalukan': 'lalu',
'melalukannya': 'lalu',
'keterlaluan': 'terlalu',
'keterlaluannya': 'terlalu',
'keterlaluanlah': 'terlalu',
'berkelaluan': 'lalu',
'melambak': 'lambak',
'terlambak': 'lambak',
'berlambak': 'lambak',
'berlambak-lambak': 'lambak',
'melanjut': 'lanjut',
'melanjutnya': 'lanjut',
'melanjutkan': 'lanjut',
'melanjutkannya': 'lanjut',
'melanjuti': 'lanjut',
'melanjutan': 'lanjut',
'lanjutan': 'lanjut',
'lanjutannya': 'lanjut',
'lanjutanlah': 'lanjut',
'pelanjut': 'lanjut',
'pelanjutnya': 'lanjut',
'pelanjutkan': 'lanjut',
'pelanjutan': 'lanjut',
'berlanjut': 'lanjut',
'berlanjutnya': 'lanjut',
'berlanjutlah': 'lanjut',
'berlanjutkan': 'lanjut',
'berlanjutan': 'lanjut',
'pelanjutannya': 'lanjut',
'kelanjutan': 'lanjut',
'kelanjutannya': 'lanjut',
'kelanjutanku': 'lanjut',
'selanjutnya': 'lanjut',
'selanjutnyalah': 'lanjut',
'selanjutnyai': 'lanjut',
'melanjutkankan': 'lanjut',
'melanjutkani': 'lanjut',
'perlanjutan': 'lanjut',
'berkelanjutan': 'lanjut',
'berkelanjutannya': 'lanjut',
'melapuk': 'lapuk',
'melapuknya': 'lapuk',
'melapukkan': 'lapuk',
'berlapuk': 'lapuk',
'pelapukan': 'lapuk',
'pelapukannya': 'lapuk',
'kelapukan': 'lapuk',
'berlapuk-lapuk': 'lapuk',
'larian': 'lari',
'lariannya': 'lari',
'pelari': 'lari',
'pelarinya': 'lari',
'pelarilah': 'lari',
'pelarikan': 'lari',
'pelarian': 'lari',
'selari': 'lari',
'berlari': 'lari',
'berlarinya': 'lari',
'berlarilah': 'lari',
'berlarikan': 'lari',
'berlarii': 'lari',
'berlarian': 'lari',
'pelariannya': 'lari',
'pelarianku': 'lari',
'berlariani': 'lari',
'melarikan': 'lari',
'melarikannya': 'lari',
'lari-lari': 'lari',
'lari-larinya': 'lari',
'lari-larian': 'lari',
'sepelarian': 'lari',
'berlari-lari': 'lari',
'berlari-larian': 'lari',
'pelatih': 'latih',
'pelatihnya': 'latih',
'pelatihlah': 'latih',
'pelatihi': 'latih',
'pelatihan': 'latih',
'pelatihnyalah': 'latih',
'pelatihku': 'latih',
'pelatihmu': 'latih',
'latihan': 'latih',
'latihannya': 'latih',
'latihanlah': 'latih',
'latihani': 'latih',
'latihanan': 'latih',
'latihanku': 'latih',
'latihanmu': 'latih',
'melatih': 'latih',
'melatihnya': 'latih',
'melatihkan': 'latih',
'melatihi': 'latih',
'melatihan': 'latih',
'melatihku': 'latih',
'melatihmu': 'latih',
'terlatih': 'latih',
'terlatihnya': 'latih',
'terlatihlah': 'latih',
'berlatih': 'latih',
'berlatihnya': 'latih',
'berlatihlah': 'latih',
'berlatihkan': 'latih',
'berlatihi': 'latih',
'berlatihan': 'latih',
'pelatihannya': 'latih',
'pelatihanan': 'latih',
'pelatihanku': 'latih',
'melawan': 'lawan',
'melawannya': 'lawan',
'melawanlah': 'lawan',
'melawankan': 'lawan',
'melawani': 'lawan',
'melawanan': 'lawan',
'melawanku': 'lawan',
'melawanmu': 'lawan',
'pelawan': 'lawan',
'pelawanan': 'lawan',
'terlawan': 'lawan',
'terlawankan': 'lawan',
'terlawanan': 'lawan',
'berlawan': 'lawan',
'berlawanan': 'lawan',
'kelawanan': 'lawan',
'perlawanan': 'lawan',
'perlawanannya': 'lawan',
'perlawananlah': 'lawan',
'perlawananan': 'lawan',
'perlawananmu': 'lawan',
'berlawanannya': 'lawan',
'berlawananan': 'lawan',
'memperlawankan': 'lawan',
'berlemak': 'lemak',
'melepas': 'lepas',
'melepasnya': 'lepas',
'melepaskan': 'lepas',
'melepaskannya': 'lepas',
'melepasi': 'lepas',
'melepasan': 'lepas',
'melepasku': 'lepas',
'melepasmu': 'lepas',
'pelepas': 'lepas',
'pelepasnya': 'lepas',
'pelepaskan': 'lepas',
'pelepasan': 'lepas',
'selepas': 'lepas',
'selepasnya': 'lepas',
'lepasan': 'lepas',
'berlepas': 'lepas',
'terlepas': 'lepas',
'terlepasnya': 'lepas',
'terlepaslah': 'lepas',
'terlepaskan': 'lepas',
'kelepasan': 'lepas',
'pelepasannya': 'lepas',
'melepaskankan': 'lepas',
'melepaskanku': 'lepas',
'melepaskanmu': 'lepas',
'memperlepas': 'lepas',
'selepas-lepas': 'lepas',
'selepas-lepasnya': 'lepas',
'liburan': 'libur',
'liburannya': 'libur',
'liburanlah': 'libur',
'liburanku': 'libur',
'liburanmu': 'libur',
'berlibur': 'libur',
'berliburnya': 'libur',
'berliburlah': 'libur',
'berliburan': 'libur',
'meliburkan': 'libur',
'meliburkannya': 'libur',
'lindungan': 'lindung',
'lindungannya': 'lindung',
'lindunganmu': 'lindung',
'pelindung': 'lindung',
'pelindungnya': 'lindung',
'pelindungi': 'lindung',
'pelindungan': 'lindung',
'pelindungku': 'lindung',
'pelindungmu': 'lindung',
'terlindung': 'lindung',
'terlindungnya': 'lindung',
'terlindungi': 'lindung',
'terlindungan': 'lindung',
'berlindung': 'lindung',
'berlindungnya': 'lindung',
'berlindunglah': 'lindung',
'berlindungi': 'lindung',
'berlindungan': 'lindung',
'melindungi': 'lindung',
'melindunginya': 'lindung',
'melindungiku': 'lindung',
'melindungimu': 'lindung',
'kelindungan': 'lindung',
'pelindungannya': 'lindung',
'melindungkan': 'lindung',
'perlindungan': 'lindung',
'perlindungannya': 'lindung',
'perlindungani': 'lindung',
'perlindunganan': 'lindung',
'memperlindungi': 'lindung',
'longgokan': 'longgok',
'berlonggok': 'longgok',
'terlonggok': 'longgok',
'melonggokkan': 'longgok',
'berlonggoklonggok': 'longgok',
'berlorong': 'lorong',
'melorongkan': 'lorong',
'pelubang': 'lubang',
'pelubangan': 'lubang',
'melubangi': 'lubang',
'melubanginya': 'lubang',
'berlubang': 'lubang',
'berlubangnya': 'lubang',
'berlubangi': 'lubang',
'berlubang-lubang': 'lubang',
'meludah': 'ludah',
'meludahlah': 'ludah',
'meludahkan': 'ludah',
'meludahkannya': 'ludah',
'meludahi': 'ludah',
'berludah': 'ludah',
'meludahinya': 'ludah',
'meludahiku': 'ludah',
'peludahan': 'ludah',
'berlumpur': 'lumpur',
'berlumpuran': 'lumpur',
'pelumpuran': 'lumpur',
'lumuran': 'lumur',
'melumur': 'lumur',
'melumurkan': 'lumur',
'melumurkannya': 'lumur',
'melumuri': 'lumur',
'berlumur': 'lumur',
'berlumurkan': 'lumur',
'berlumuran': 'lumur',
'melumurinya': 'lumur',
'berlumut': 'lumut',
'berlumutan': 'lumut',
'melutut': 'lutut',
'berlutut': 'lutut',
'berlututlah': 'lutut',
'bermakna': 'makna',
'bermaknanya': 'makna',
'memaknakan': 'makna',
'membermaknakan': 'makna',
'dimaksud': 'maksud',
'dimaksudnya': 'maksud',
'dimaksudkan': 'maksud',
'dimaksudkannya': 'maksud',
'dimaksudan': 'maksud',
'termaksud': 'maksud',
'bermaksud': 'maksud',
'bermaksudkan': 'maksud',
'semalam': 'malam',
'semalamnya': 'malam',
'semalaman': 'malam',
'memalami': 'malam',
'bermalam': 'malam',
'bermalamnya': 'malam',
'bermalamlah': 'malam',
'kemalaman': 'malam',
'pemalaman': 'palam',
'permalaman': 'malam',
'memalamkan': 'malam',
'malam-malam': 'malam',
'malam-malamnya': 'malam',
'malam-malamlah': 'malam',
'malam-malamku': 'malam',
'bermalam-malam': 'malam',
'mempermalamkan': 'malam',
'semalam-malaman': 'malam',
'bermanfaat': 'manfaat',
'bermanfaatnya': 'manfaat',
'bermanfaatlah': 'manfaat',
'bermanfaatkan': 'manfaat',
'kemanfaatan': 'manfaat',
'kemanfaatannya': 'manfaat',
'pemanfaatan': 'manfaat',
'pemanfaatannya': 'manfaat',
'pemanfaatanan': 'manfaat',
'memanfaatkan': 'manfaat',
'memanfaatkannya': 'manfaat',
'memanfaatkankan': 'manfaat',
'memanfaatkanmu': 'manfaat',
'bermastautin': 'mastautin',
'semata': 'mata',
'sematanya': 'mata',
'sematai': 'mata',
'bermata': 'mata',
'bermatakan': 'mata',
'semata-mata': 'semata',
'termata-mata': 'mata',
'pemenung': 'menung',
'bermenung': 'menung',
'termenung': 'menung',
'kemenungan': 'menung',
'memenungkan': 'menung',
'bermenung-menung': 'menung',
'termenung-menung': 'menung',
'mimpian': 'mimpi',
'pemimpi': 'mimpi',
'pemimpinya': 'mimpi',
'pemimpilah': 'mimpi',
'pemimpian': 'mimpi',
'bermimpi': 'mimpi',
'bermimpinya': 'mimpi',
'bermimpilah': 'mimpi',
'bermimpikan': 'mimpi',
'memimpikan': 'mimpi',
'memimpikannya': 'mimpi',
'termimpi-mimpi': 'mimpi',
'peminat': 'minat',
'peminatnya': 'minat',
'peminatan': 'minat',
'meminati': 'minat',
'meminatinya': 'minat',
'meminatiku': 'minat',
'berminat': 'minat',
'berminatnya': 'minat',
'berminatkan': 'minat',
'meminyaki': 'minyak',
'meminyakinya': 'minyak',
'berminyak': 'minyak',
'perminyakan': 'minyak',
'perminyakannya': 'minyak',
'berminyak-minyak': 'minyak',
'bermoral': 'moral',
'bermoralnya': 'moral',
'memotori': 'motor',
'memotorinya': 'motor',
'bermotor': 'motor',
'bermotornya': 'motor',
'pemuka': 'muka',
'pemukanya': 'muka',
'pemukaan': 'muka',
'semuka': 'muka',
'ke muka': 'muka',
'di muka': 'muka',
'bermuka': 'muka',
'mengemuka': 'muka',
'mengemukanya': 'muka',
'mengemukakan': 'muka',
'mengemukakannya': 'muka',
'mengemukaan': 'muka',
'bersemuka': 'muka',
'terkemuka': 'muka',
'terkemukanya': 'muka',
'permukaan': 'muka',
'permukaannya': 'muka',
'pengemukaan': 'muka',
'bermuka-muka': 'muka',
'menyemukakan': 'muka',
'muka-muka': 'muka',
'bermukah': 'mukah',
'bermuram': 'muram',
'kemuraman': 'muram',
'kemuramannya': 'muram',
'memuramkan': 'muram',
'bermusuh': 'musuh',
'bermusuhkan': 'musuh',
'bermusuhan': 'musuh',
'memusuhi': 'musuh',
'memusuhinya': 'musuh',
'memusuhimu': 'musuh',
'bermusuhannya': 'musuh',
'permusuhan': 'musuh',
'permusuhannya': 'musuh',
'semutu': 'mutu',
'bermutu': 'mutu',
'bermutunya': 'mutu',
'bermutulah': 'mutu',
'bernafsu': 'nafsu',
'bernafsunya': 'nafsu',
'bernama': 'nama',
'bernamanya': 'nama',
'bernamakan': 'nama',
'bernamai': 'nama',
'menamai': 'nama',
'menamainya': 'nama',
'menamaiku': 'nama',
'menamaimu': 'nama',
'ternama': 'nama',
'ternamanya': 'nama',
'kenamaan': 'nama',
'kenamaannya': 'nama',
'penamaan': 'nama',
'penamaannya': 'nama',
'menamakan': 'nama',
'menamakannya': 'nama',
'menanah': 'nanah',
'menanahan': 'nanah',
'bernanah': 'nanah',
'bernanahnya': 'nanah',
'senasib': 'nasib',
'senasibnya': 'nasib',
'senasiblah': 'nasib',
'bernasib': 'nasib',
'nasib-nasiban': 'nasib',
'penaung': 'naung',
'penaungan': 'naung',
'naungan': 'naung',
'naungannya': 'naung',
'bernaung': 'naung',
'bernaungnya': 'naung',
'menaungi': 'taung',
'menaunginya': 'taung',
'bernazar': 'nazar',
'menazarkan': 'nazar',
'berniat': 'niat',
'berniatnya': 'niat',
'berniatlah': 'niat',
'berniatan': 'niat',
'terniat': 'niat',
'meniatkan': 'niat',
'meniatkannya': 'niat',
'berniat-niat': 'niat',
'bernitrogen': 'nitrogen',
'menyala': 'nyala',
'menyalanya': 'nyala',
'menyalakan': 'salak',
'menyalakannya': 'nyala',
'menyalai': 'salai',
'bernyala': 'nyala',
'menyala-nyala': 'nyala',
'bernyala-nyala': 'nyala',
'nyanyian': 'nyanyi',
'nyanyiannya': 'nyanyi',
'nyanyianku': 'nyanyi',
'nyanyianmu': 'nyanyi',
'menyanyi': 'nyanyi',
'menyanyinya': 'nyanyi',
'menyanyilah': 'nyanyi',
'menyanyikan': 'nyanyi',
'menyanyikannya': 'nyanyi',
'menyanyian': 'nyanyi',
'penyanyi': 'nyanyi',
'penyanyinya': 'nyanyi',
'penyanyikan': 'nyanyi',
'penyanyian': 'nyanyi',
'bernyanyi': 'nyanyi',
'bernyanyinya': 'nyanyi',
'bernyanyilah': 'nyanyi',
'pemberokan': 'berok',
'berolahraga': 'olahraga',
'berolahraganya': 'olahraga',
'berolahragalah': 'olahraga',
'keolahragaan': 'olahraga',
'keolahragaannya': 'olahraga',
'mengolahragakan': 'olahraga',
'memberolahragakan': 'olahraga',
'olakan': 'olak',
'berolak': 'olak',
'mengolak': 'olak',
'perolakan': 'olak',
'memberon': 'beron',
'berondongan': 'berondong',
'memberondong': 'berondong',
'memberondongnya': 'berondong',
'memberondongkan': 'berondong',
'memberondongkannya': 'berondong',
'memberondongan': 'berondong',
'pemberondongan': 'berondong',
'memberongsang': 'berongsang',
'memberongsong': 'berongsong',
'pemberontak': 'berontak',
'pemberontaknya': 'berontak',
'pemberontaklah': 'berontak',
'pemberontakkan': 'berontak',
'pemberontakan': 'berontak',
'memberontak': 'berontak',
'pemberontakannya': 'berontak',
'memberosot': 'berosot',
'memadu': 'padu',
'memadunya': 'padu',
'memadukan': 'padu',
'memadukannya': 'padu',
'paduan': 'padu',
'paduannya': 'padu',
'pemadu': 'padu',
'pemaduan': 'padu',
'berpadu': 'padu',
'berpadunya': 'padu',
'berpadukan': 'padu',
'berpaduan': 'padu',
'terpadu': 'padu',
'terpadunya': 'padu',
'terpadukan': 'padu',
'kepaduan': 'padu',
'perpaduan': 'padu',
'perpaduannya': 'padu',
'keterpaduan': 'padu',
'keterpaduanlah': 'padu',
'berpadu-padu': 'padu',
'memperpadukan': 'padu',
'pemahat': 'pahat',
'pemahatnya': 'pahat',
'pemahatan': 'pahat',
'pahatan': 'pahat',
'pahatannya': 'pahat',
'memahat': 'pahat',
'memahatnya': 'pahat',
'memahatkan': 'pahat',
'berpahat': 'pahat',
'berpahatkan': 'pahat',
'berpakat': 'pakat',
'memakati': 'pakat',
'memalit': 'palit',
'terpalit': 'palit',
'berpalit': 'palit',
'terpalit-palit': 'palit',
'pemandang': 'pandang',
'pemandangan': 'pandang',
'memandang': 'pandang',
'memandangnya': 'pandang',
'memandanglah': 'pandang',
'memandangi': 'pandang',
'memandangan': 'pandang',
'memandangku': 'pandang',
'memandangmu': 'pandang',
'pandangan': 'pandang',
'pandangannya': 'pandang',
'pandanganlah': 'pandang',
'pandanganan': 'pandang',
'pandanganku': 'pandang',
'pandanganmu': 'pandang',
'terpandang': 'pandang',
'terpandanglah': 'pandang',
'memandanginya': 'pandang',
'memandangiku': 'pandang',
'pemandangannya': 'pandang',
'pemandanganku': 'pandang',
'berpandangan': 'pandang',
'berpandangannya': 'pandang',
'berpandanganlah': 'pandang',
'sepemandangan': 'pandang',
'pandang-memandang': 'pandang',
'terpandang-pandang': 'pandang',
'berpandang-pandangan': 'pandang',
'sepangkat': 'pangkat',
'berpangkat': 'pangkat',
'pemangkatan': 'pangkat',
'kepangkatan': 'pangkat',
'kepangkatannya': 'pangkat',
'memangkatkan': 'pangkat',
'berpangkat-pangkat': 'pangkat',
'memapas': 'papas',
'papasan': 'papas',
'pemapasan': 'papas',
'berpapasan': 'papas',
'memarut': 'parut',
'memarutnya': 'parut',
'parutan': 'parut',
'parutannya': 'parut',
'pemarut': 'parut',
'pemarutnya': 'parut',
'berparut': 'parut',
'pautan': 'paut',
'memaut': 'paut',
'memautkan': 'paut',
'berpaut': 'paut',
'berpautan': 'paut',
'terpaut': 'paut',
'terpautnya': 'paut',
'perpautan': 'paut',
'paut-memaut': 'paut',
'berpautan': 'paut',
'berpaya': 'paya',
'berpeluh': 'peluh',
'berpeluh-peluh': 'peluh',
'pemeluk': 'peluk',
'pemeluknya': 'peluk',
'pemelukan': 'peluk',
'memeluk': 'peluk',
'memeluknya': 'peluk',
'memeluki': 'peluk',
'memelukan': 'peluk',
'memelukku': 'peluk',
'memelukmu': 'peluk',
'pelukan': 'peluk',
'pelukannya': 'peluk',
'pelukanku': 'peluk',
'pelukanmu': 'peluk',
'berpeluk': 'peluk',
'berpelukkan': 'peluk',
'berpelukan': 'peluk',
'terpeluk': 'peluk',
'sepemeluk': 'peluk',
'berpelukanlah': 'peluk',
'sepemelukan': 'peluk',
'berpeluk-pelukan': 'peluk',
'berpengaruh': 'pengaruh',
'berpengaruhnya': 'pengaruh',
'berpengaruhlah': 'pengaruh',
'berpengaruhkan': 'pengaruh',
'berpengaruhi': 'pengaruh',
'terpengaruh': 'pengaruh',
'terpengaruhnya': 'pengaruh',
'terpengaruhi': 'pengaruh',
'memengaruhi': 'pengaruh',
'memengaruhinya': 'pengaruh',
'memengaruhii': 'pengaruh',
'memengaruhiku': 'pengaruh',
'memengaruhimu': 'pengaruh',
'setahu': 'tahu',
'setahunya': 'tahu',
'setahui': 'tahu',
'setahuan': 'tahu',
'setahuku': 'tahu',
'ketahuan': 'tahu',
'ketahuannya': 'tahu',
'ketahuanlah': 'tahu',
'tahu-tahu': 'tahu',
'tahu-tahunya': 'tahu',
'bertahuan': 'tahu',
'bertahukan': 'tahu',
'mengetahui': 'tahu',
'mengetahuinya': 'tahu',
'mengetahuilah': 'tahu',
'mengetahuii': 'tahu',
'mengetahuiku': 'tahu',
'mengetahuimu': 'tahu',
'tahu-menahu': 'tahu',
'pengetahuan': 'tahu',
'pengetahuannya': 'tahu',
'pengetahuanlah': 'tahu',
'pengetahuanku': 'tahu',
'pengetahuanmu': 'tahu',
'bertahu-tahu': 'tahu',
'berpengetahuan': 'tahu',
'berpengetahuanlah': 'tahu',
'berperangai': 'perangai',
'berperikemanusiaan': 'perikemanusiaan',
'berperikemanusiaannya': 'perikemanusiaan',
'memesan': 'pesan',
'memesannya': 'pesan',
'memesankan': 'pesan',
'memesankannya': 'pesan',
'memesanan': 'pesan',
'pesanan': 'pesan',
'pesanannya': 'pesan',
'pesananan': 'pesan',
'pesananku': 'pesan',
'pesananmu': 'pesan',
'sipesan': 'pesan',
'pemesan': 'pesan',
'pemesannya': 'pesan',
'pemesanan': 'pesan',
'sepesan': 'pesan',
'memesani': 'pesan',
'berpesan': 'pesan',
'pemesanannya': 'pesan',
'pemesananan': 'pesan',
'pesan-pesan': 'pesan',
'pesan-pesannya': 'pesan',
'pesan-pesanan': 'pesan',
'berpesta': 'pesta',
'berpestanya': 'pesta',
'berpestalah': 'pesta',
'memestakan': 'pesta',
'berpesta-pesta': 'pesta',
'berpidato': 'pidato',
'berpidatonya': 'pidato',
'memidatokan': 'pidato',
'memijak': 'pijak',
'memijakkan': 'pijak',
'memijaki': 'pijak',
'memijakan': 'pijak',
'pemijak': 'pijak',
'pijakan': 'pijak',
'pijakannya': 'pijak',
'berpijak': 'pijak',
'berpijaknya': 'pijak',
'berpijaklah': 'pijak',
'pemijakan': 'pijak',
'pijak-pijak': 'pijak',
'terpijak-pijak': 'pijak',
'memijar': 'pijar',
'memijarkan': 'pijar',
'berpijar': 'pijar',
'berpijaran': 'pijar',
'pijar-pijar': 'pijar',
'memijar-mijar': 'pijar',
'berpijar-pijar': 'pijar',
'memikir': 'pikir',
'memikirnya': 'pikir',
'memikirkan': 'pikir',
'memikirkannya': 'pikir',
'memikiran': 'pikir',
'pemikir': 'pikir',
'pemikirnya': 'pikir',
'pemikiran': 'pikir',
'pikiran': 'pikir',
'pikirannya': 'pikir',
'pikiranlah': 'pikir',
'pikirankan': 'pikir',
'pikiranku': 'pikir',
'pikiranmu': 'pikir',
'berpikir': 'pikir',
'berpikirnya': 'pikir',
'berpikirlah': 'pikir',
'berpikirkan': 'pikir',
'berpikiri': 'pikir',
'berpikiran': 'pikir',
'berpikirku': 'pikir',
'berpikirmu': 'pikir',
'terpikir': 'pikir',
'terpikirkan': 'pikir',
'terpikirkannya': 'pikir',
'terpikiran': 'pikir',
'memikiri': 'pikir',
'memikirikan': 'pikir',
'memikirikannya': 'pikir',
'pemikirannya': 'pikir',
'pemikiranku': 'pikir',
'pemikiranmu': 'pikir',
'sepikiran': 'pikir',
'memikirkankan': 'pikir',
'memikirkanku': 'pikir',
'memikirkanmu': 'pikir',
'berpikirannya': 'pikir',
'berpikiranlah': 'pikir',
'memikir-mikir': 'pikir',
'berpikir-pikir': 'pikir',
'berpikir-pikiran': 'pikir',
'memikir-mikirkan': 'pikir',
'memindah': 'pindah',
'memindahnya': 'pindah',
'memindahkan': 'pindah',
'memindahkannya': 'pindah',
'memindahan': 'pindah',
'pindahan': 'pindah',
'pindahannya': 'pindah',
'memindahi': 'pindah',
'berpindah': 'pindah',
'berpindahnya': 'pindah',
'berpindahlah': 'pindah',
'berpindahan': 'pindah',
'pemindahan': 'pindah',
'pemindahannya': 'pindah',
'pemindahanan': 'pindah',
'kepindahan': 'pindah',
'kepindahannya': 'pindah',
'kepindahanku': 'pindah',
'memindahkanan': 'pindah',
'perpindahan': 'pindah',
'perpindahannya': 'pindah',
'perpindahanku': 'pindah',
'berpindah-pindah': 'pindah',
'berpindah-pindahnya': 'pindah',
'memintal': 'pintal',
'memintalnya': 'pintal',
'pemintal': 'pintal',
'pemintalan': 'pintal',
'terpintal': 'pintal',
'berpintal': 'pintal',
'berpintal-pintal': 'pintal',
'pisahan': 'pisah',
'memisah': 'pisah',
'memisahnya': 'pisah',
'memisahkan': 'pisah',
'memisahkannya': 'pisah',
'memisahan': 'pisah',
'pemisah': 'pisah',
'pemisahnya': 'pisah',
'pemisahkan': 'pisah',
'pemisahan': 'pisah',
'terpisah': 'pisah',
'terpisahnya': 'pisah',
'terpisahkan': 'pisah',
'terpisahkannya': 'pisah',
'berpisah': 'pisah',
'berpisahnya': 'pisah',
'berpisahlah': 'pisah',
'berpisahan': 'pisah',
'pemisahannya': 'pisah',
'perpisahan': 'pisah',
'perpisahannya': 'pisah',
'memisahkanlah': 'pisah',
'memisahkankan': 'pisah',
'memisahkanku': 'pisah',
'berpisah-pisah': 'pisah',
'memisah-misahkan': 'pisah',
'memisah-misahkannya': 'pisah',
'berpolitik': 'politik',
'berpolitiknya': 'politik',
'berpolitiklah': 'politik',
'pemolitikan': 'politik',
'memolitikkan': 'politik',
'memperpolitikkan': 'politik',
'berpotensi': 'potensi',
'berpotensinya': 'potensi',
'berprinsip': 'prinsip',
'berprinsiplah': 'prinsip',
'berprinsipkan': 'prinsip',
'berpuasa': 'puasa',
'berpuasanya': 'puasa',
'berpuasalah': 'puasa',
'pusingan': 'pusing',
'pemusing': 'pusing',
'memusing': 'pusing',
'memusingkan': 'pusing',
'memusingkannya': 'pusing',
'berpusing': 'pusing',
'berpusingnya': 'pusing',
'berpusingan': 'pusing',
'pemusingan': 'pusing',
'perpusingan': 'pusing',
'pusing-pusing': 'pusing',
'pusing-pusingnya': 'pusing',
'terpusing-pusing': 'pusing',
'berpusing-pusing': 'pusing',
'pemutar': 'putar',
'pemutarnya': 'putar',
'pemutaran': 'putar',
'putaran': 'putar',
'putarannya': 'putar',
'seputar': 'putar',
'seputarnya': 'putar',
'seputaran': 'putar',
'memutar': 'putar',
'memutarnya': 'putar',
'memutarkan': 'putar',
'memutarkannya': 'putar',
'memutari': 'putar',
'memutaran': 'putar',
'berputar': 'putar',
'berputarnya': 'putar',
'berputarlah': 'putar',
'terputar': 'putar',
'terputarnya': 'putar',
'pemutarannya': 'putar',
'pemutaranan': 'putar',
'perputaran': 'putar',
'perputarannya': 'putar',
'putar-putar': 'putar',
'putar-putaran': 'putar',
'memutar-mutar': 'putar',
'memutar-mutarkan': 'putar',
'memperputarkan': 'putar',
'berputar-putar': 'putar',
'menyalam': 'salam',
'menyalami': 'salam',
'bersalam': 'salam',
'bersalaman': 'salam',
'menyalaminya': 'salam',
'persalaman': 'salam',
'bersalamannya': 'salam',
'bersalamanlah': 'salam',
'bersalamanan': 'salam',
'bersalam-salaman': 'salam',
'salinan': 'salin',
'salinannya': 'salin',
'pesalin': 'salin',
'pesalinan': 'salin',
'sesalin': 'salin',
'persalin': 'salin',
'persalinan': 'salin',
'menyalin': 'salin',
'menyalinnya': 'salin',
'menyalinkan': 'salin',
'menyalinan': 'salin',
'bersalin': 'salin',
'bersalinnya': 'salin',
'bersalinan': 'salin',
'penyalin': 'salin',
'penyalinan': 'salin',
'menyalini': 'salin',
'penyalinanan': 'salin',
'persalinannya': 'salin',
'persalinanku': 'salin',
'persalinanmu': 'salin',
'mempersalin': 'salin',
'mempersalini': 'salin',
'bersalin-salin': 'salin',
'mempersalinkan': 'salin',
'sesama': 'sama',
'sesamanya': 'sama',
'sesamalah': 'sama',
'sesamamu': 'sama',
'bersama': 'sama',
'bersamanya': 'sama',
'bersamalah': 'sama',
'bersamai': 'sama',
'bersamaan': 'sama',
'bersamaku': 'sama',
'bersamamu': 'sama',
'menyamai': 'sama',
'menyamainya': 'sama',
'menyamaikan': 'sama',
'menyamaikannya': 'sama',
'tersamai': 'sama',
'kesamaan': 'sama',
'kesamaannya': 'sama',
'persamaan': 'sama',
'persamaannya': 'sama',
'persamaanlah': 'sama',
'bersamaannya': 'sama',
'sama-sama': 'sama',
'sama-samalah': 'sama',
'penyamaan': 'sama',
'menyamakan': 'samak',
'menyamakannya': 'sama',
'kebersamaan': 'sama',
'kebersamaannya': 'sama',
'kebersamaanlah': 'sama',
'kebersamaanku': 'sama',
'kebersamaanmu': 'sama',
'bersama-sama': 'sama',
'bersama-samanya': 'sama',
'bersama-samalah': 'sama',
'bersama-samakan': 'sama',
'bersama-samaan': 'sama',
'bersama-samamu': 'sama',
'membersamakan': 'sama',
'mempersamakan': 'sama',
'menyama-nyama': 'sama',
'menyama-nyamakan': 'sama',
'menyama-nyamakannya': 'sama',
'menyama-nyamai': 'sama',
'mempersama-samakan': 'sama',
'sandaran': 'sandar',
'sandarannya': 'sandar',
'bersandar': 'sandar',
'bersandarnya': 'sandar',
'bersandarlah': 'sandar',
'bersandarkan': 'sandar',
'bersandaran': 'sandar',
'tersandar': 'sandar',
'menyandar': 'sandar',
'menyandarkan': 'sandar',
'menyandarkannya': 'sandar',
'menyandari': 'sandar',
'penyandar': 'sandar',
'penyandaran': 'sandar',
'pesandaran': 'sandar',
'penyandarannya': 'sandar',
'persandaran': 'sandar',
'sandar-menyandar': 'sandar',
'bersarang': 'sarang',
'bersarangnya': 'sarang',
'menyarangkan': 'sarang',
'menyarangkannya': 'sarang',
'bersarang-sarang': 'sarang',
'menyarung': 'sarung',
'menyarungkan': 'sarung',
'menyarungi': 'sarung',
'tersarung': 'sarung',
'bersarung': 'sarung',
'bersarungkan': 'sarung',
'bersarungan': 'sarung',
'kesatu': 'satu',
'kesatuan': 'satu',
'satuan': 'satu',
'satuannya': 'satu',
'satuanlah': 'satu',
'satuanmu': 'satu',
'bersatu': 'satu',
'bersatunya': 'satu',
'bersatulah': 'satu',
'bersatukan': 'satu',
'bersatuan': 'satu',
'penyatu': 'satu',
'penyatukan': 'satu',
'penyatuan': 'satu',
'menyatu': 'satu',
'menyatunya': 'satu',
'menyatulah': 'satu',
'menyatukan': 'satu',
'menyatukannya': 'satu',
'menyatui': 'satu',
'menyatuan': 'satu',
'kesatuannya': 'satu',
'kesatuanlah': 'satu',
'kesatuanmu': 'satu',
'persatuan': 'satu',
'persatuannya': 'satu',
'persatuanlah': 'satu',
'persatuani': 'satu',
'penyatuannya': 'satu',
'satu-satu': 'satu',
'satu-satunya': 'satu',
'satu-satulah': 'satu',
'satu-satuan': 'satu',
'pemersatu': 'satu',
'pemersatunya': 'satu',
'pemersatuan': 'satu',
'menyatukanlah': 'satu',
'satu-satunyanya': 'satu',
'mempersatukan': 'satu',
'mempersatukannya': 'satu',
'bersaudara': 'saudara',
'bersaudaranya': 'saudara',
'bersaudaralah': 'saudara',
'bersaudaraan': 'saudara',
'bersaudaraku': 'saudara',
'persaudaraan': 'saudara',
'persaudaraannya': 'saudara',
'mempersaudarakan': 'saudara',
'sediaan': 'sedia',
'sediaannya': 'sedia',
'sedianya': 'sedia',
'tersedia': 'sedia',
'tersedianya': 'sedia',
'tersediakan': 'sedia',
'tersediaan': 'sedia',
'penyedia': 'sedia',
'penyedianya': 'sedia',
'penyediakan': 'sedia',
'penyediaan': 'sedia',
'bersedia': 'sedia',
'bersedianya': 'sedia',
'bersedialah': 'sedia',
'bersediaan': 'sedia',
'kesediaan': 'sedia',
'kesediaannya': 'sedia',
'penyediaannya': 'sedia',
'persediaan': 'sedia',
'persediaannya': 'sedia',
'menyediakan': 'sedia',
'menyediakannya': 'sedia',
'ketersediaan': 'sedia',
'ketersediaannya': 'sedia',
'mempersediakan': 'sedia',
'bersedia-sedia': 'sedia',
'bersejarah': 'sejarah',
'bersejarahnya': 'sejarah',
'menyejarah': 'sejarah',
'kesejarahan': 'sejarah',
'kesejarahannya': 'sejarah',
'kesejarahanan': 'sejarah',
'menyejarahkan': 'sejarah',
'sekolahan': 'sekolah',
'sekolahannya': 'sekolah',
'bersekolah': 'sekolah',
'bersekolahnya': 'sekolah',
'persekolahan': 'sekolah',
'menyekolahkan': 'sekolah',
'menyekolahkannya': 'sekolah',
'menyekolahkanku': 'sekolah',
'sekongkolan': 'sekongkol',
'bersekongkol': 'sekongkol',
'bersekongkolnya': 'sekongkol',
'persekongkolan': 'sekongkol',
'persekongkolannya': 'sekongkol',
'peselancar': 'selancar',
'peselancarnya': 'selancar',
'peselancaran': 'selancar',
'berselancar': 'selancar',
'berselancarnya': 'selancar',
'berselancarlah': 'selancar',
'menyelaput': 'selaput',
'berselaput': 'selaput',
'berselera': 'selera',
'berselerak': 'selerak',
'berselindung': 'selindung',
'berselirat': 'selirat',
'berselisih': 'selisih',
'berselisihlah': 'selisih',
'berselisihkan': 'selisih',
'berselisihan': 'selisih',
'perselisihan': 'selisih',
'perselisihannya': 'selisih',
'menyelisihkan': 'selisih',
'memperselisihkan': 'selisih',
'memperselisihkannya': 'selisih',
'berseloroh': 'seloroh',
'berselumu': 'selumu',
'bersemadi': 'semadi',
'persemadian': 'semadi',
'menyemarak': 'semarak',
'menyemarakkan': 'semarak',
'menyemarakkannya': 'semarak',
'menyemaraki': 'semarak',
'menyemarakan': 'semarak',
'bersemarak': 'semarak',
'kesemarakan': 'semarak',
'kesemarakannya': 'semarak',
'sembahyangan': 'sembahyang',
'bersembahyang': 'sembahyang',
'bersembahyangan': 'sembahyang',
'menyembahyangi': 'sembahyang',
'persembahyangan': 'sembahyang',
'menyembahyangkan': 'sembahyang',
'bersembunyi': 'sembunyi',
'bersembunyinya': 'sembunyi',
'bersembunyilah': 'sembunyi',
'tersembunyi': 'sembunyi',
'tersembunyinya': 'sembunyi',
'tersembunyikan': 'sembunyi',
'penyembunyian': 'sembunyi',
'penyembunyiannya': 'sembunyi',
'persembunyian': 'sembunyi',
'persembunyiannya': 'sembunyi',
'persembunyianku': 'sembunyi',
'menyembunyikan': 'sembunyi',
'menyembunyikannya': 'sembunyi',
'sembunyi-sembunyi': 'sembunyi',
'sembunyi-sembunyikan': 'sembunyi',
'sembunyi-sembunyian': 'sembunyi',
'bersembunyi-sembunyi': 'sembunyi',
'bersembunyi-sembunyian': 'sembunyi',
'senandungan': 'senandung',
'bersenandung': 'senandung',
'bersenandunglah': 'senandung',
'bersenandungkan': 'senandung',
'menyenandungkan': 'senandung',
'menyendi': 'sendi',
'bersendi': 'sendi',
'bersendikan': 'sendi',
'persendian': 'sendi',
'persendiannya': 'sendi',
'persendianku': 'sendi',
'menyendikan': 'sendi',
'bersendi-sendi': 'sendi',
'mempersendikan': 'sendi',
'menyendi-nyendi': 'sendi',
'senggatan': 'senggat',
'menyenggat': 'senggat',
'bersenggat': 'senggat',
'bersenggayut': 'senggayut',
'bersenggayutan': 'senggayut',
'bersengketa': 'sengketa',
'bersengketanya': 'sengketa',
'persengketaan': 'sengketa',
'persengketaannya': 'sengketa',
'mempersengketakan': 'sengketa',
'mempersengketakannya': 'sengketa',
'sentuhan': 'sentuh',
'sentuhannya': 'sentuh',
'sentuhanku': 'sentuh',
'menyentuh': 'sentuh',
'menyentuhnya': 'sentuh',
'menyentuhlah': 'sentuh',
'menyentuhkan': 'sentuh',
'menyentuhkannya': 'sentuh',
'menyentuhku': 'sentuh',
'menyentuhmu': 'sentuh',
'bersentuh': 'sentuh',
'bersentuhkan': 'sentuh',
'bersentuhan': 'sentuh',
'tersentuh': 'sentuh',
'tersentuhnya': 'sentuh',
'tersentuhlah': 'sentuh',
'penyentuh': 'sentuh',
'penyentuhan': 'sentuh',
'kesentuhan': 'sentuh',
'persentuhan': 'sentuh',
'persentuhannya': 'sentuh',
'menyentuh-nyentuh': 'sentuh',
'tersepai': 'sepai',
'bersepai': 'sepai',
'bersepaian': 'sepai',
'bersepakat': 'sepakat',
'bersepakatan': 'sepakat',
'kesepakatan': 'sepakat',
'kesepakatannya': 'sepakat',
'kesepakatanlah': 'sepakat',
'kesepakatani': 'sepakat',
'kesepakatanan': 'sepakat',
'menyepakati': 'sepakat',
'menyepakatinya': 'sepakat',
'menyepakatii': 'sepakat',
'persepakatan': 'sepakat',
'bersepatu': 'sepatu',
'menyepatui': 'sepatu',
'persepatuan': 'sepatu',
'bersepeda': 'sepeda',
'bersepedanya': 'sepeda',
'bersepedalah': 'sepeda',
'sesepuh': 'sepuh',
'sesepuhnya': 'sepuh',
'sepuhan': 'sepuh',
'penyepuh': 'sepuh',
'penyepuhan': 'sepuh',
'menyepuh': 'sepuh',
'menyepuhnya': 'sepuh',
'menyepuhkan': 'sepuh',
'tersepuh': 'sepuh',
'bersepuh': 'sepuh',
'kesepuhan': 'sepuh',
'berserabut': 'serabut',
'berserabutan': 'serabut',
'berserat': 'serat',
'terserat': 'serat',
'menyeratkan': 'serat',
'bersiang': 'siang',
'menyiang': 'siang',
'menyiangi': 'siang',
'menyiangan': 'siang',
'menyianginya': 'siang',
'kesiangan': 'siang',
'kesianganlah': 'siang',
'penyiangan': 'siang',
'siang-siang': 'siang',
'siang-siangan': 'siang',
'mempersiang': 'siang',
'mempersiangi': 'siang',
'bersidang': 'sidang',
'bersidangnya': 'sidang',
'bersidangan': 'sidang',
'persidangan': 'sidang',
'persidangannya': 'sidang',
'persidanganlah': 'sidang',
'persidanganan': 'sidang',
'penyidangan': 'sidang',
'penyidangannya': 'sidang',
'menyidangkan': 'sidang',
'menyidangkannya': 'sidang',
'bersifat': 'sifat',
'bersifatnya': 'sifat',
'bersifatlah': 'sifat',
'penyifatan': 'sifat',
'menyifatkan': 'sifat',
'tersifatkan': 'sifat',
'pembersih': 'bersih',
'pembersihnya': 'bersih',
'pembersihkan': 'bersih',
'pembersihan': 'bersih',
'kebersihan': 'bersih',
'kebersihannya': 'bersih',
'kebersihanlah': 'bersih',
'kebersihanan': 'bersih',
'kebersihanku': 'bersih',
'pembersihannya': 'bersih',
'membersihkan': 'bersih',
'membersihkannya': 'bersih',
'membersihkanlah': 'bersih',
'membersihkankan': 'bersih',
'membersil': 'bersil',
'silangan': 'silang',
'bersilang': 'silang',
'bersilangan': 'silang',
'tersilang': 'silang',
'menyilang': 'silang',
'menyilangnya': 'silang',
'menyilangkan': 'silang',
'menyilangkannya': 'silang',
'menyilangi': 'silang',
'penyilangan': 'silang',
'persilangan': 'silang',
'persilangannya': 'silang',
'mempersilangkan': 'silang',
'silang-menyilang': 'silang',
'bersimbol': 'simbol',
'bersimbolkan': 'simbol',
'menyimbolkan': 'simbol',
'sinaran': 'sinar',
'sinarannya': 'sinar',
'bersinar': 'sinar',
'bersinarnya': 'sinar',
'bersinarlah': 'sinar',
'bersinari': 'sinar',
'menyinar': 'sinar',
'menyinarkan': 'sinar',
'menyinarkannya': 'sinar',
'menyinari': 'sinar',
'menyinarinya': 'sinar',
'penyinaran': 'sinar',
'penyinarannya': 'sinar',
'sinar-seminar': 'sinar',
'sinar-suminar': 'sinar',
'sinar-menyinar': 'sinar',
'bersirip': 'sirip',
'menyirip': 'sirip',
'tebersit': 'bersit',
'tebersitlah': 'bersit',
'bersitan': 'bersit',
'membersit': 'bersit',
'membersitkan': 'bersit',
'bersiut': 'siut',
'pesolek': 'solek',
'bersolek': 'solek',
'bersoleknya': 'solek',
'mempersolek': 'solek',
'solek-menyolek': 'solek',
'penyorak': 'sorak',
'bersorak': 'sorak',
'menyoraki': 'sorak',
'menyorakinya': 'sorak',
'menyorakkan': 'sorak',
'penyuci': 'suci',
'penyucian': 'suci',
'bersuci': 'suci',
'kesucian': 'suci',
'kesuciannya': 'suci',
'persucian': 'suci',
'menyucikan': 'suci',
'menyumpah': 'sumpah',
'menyumpahnya': 'sumpah',
'menyumpahi': 'sumpah',
'bersumpah': 'sumpah',
'bersumpahlah': 'sumpah',
'penyumpah': 'sumpah',
'penyumpahan': 'sumpah',
'menyumpahinya': 'sumpah',
'menyumpahimu': 'sumpah',
'persumpahan': 'sumpah',
'mempersumpahkan': 'sumpah',
'bersumpah-sumpahan': 'sumpah',
'bersungut': 'sungut',
'sungut-sungut': 'sungut',
'bersungut-sungut': 'sungut',
'menyurai': 'surai',
'bersurai': 'surai',
'suratan': 'surat',
'suratannya': 'surat',
'bersurat': 'surat',
'tersurat': 'surat',
'menyurat': 'surat',
'menyuratnya': 'surat',
'menyuratkan': 'surat',
'menyurati': 'surat',
'menyuratinya': 'surat',
'persuratan': 'surat',
'persuratannya': 'surat',
'surat-menyurat': 'surat',
'surat-menyuratnya': 'surat',
'bersusah payah': 'susah payah',
'membersut': 'bersut',
'syarahan': 'syarah',
'pensyarah': 'syarah',
'bersyarah': 'syarah',
'mensyarahkan': 'syarah',
'bersyarat': 'syarat',
'bersyaratnya': 'syarat',
'bersyaratkan': 'syarat',
'bersyaratan': 'syarat',
'persyaratan': 'syarat',
'persyaratannya': 'syarat',
'mensyaratkan': 'syarat',
'mensyaratkannya': 'syarat',
'menabur': 'tabur',
'menaburnya': 'tabur',
'menaburkan': 'tabur',
'menaburkannya': 'tabur',
'menaburi': 'tabur',
'penabur': 'tabur',
'penaburan': 'tabur',
'taburan': 'tabur',
'taburannya': 'tabur',
'tertabur': 'tabur',
'bertabur': 'tabur',
'bertaburnya': 'tabur',
'bertaburkan': 'tabur',
'bertaburan': 'tabur',
'menaburinya': 'tabur',
'bertaburannya': 'tabur',
'bertabur-tabur': 'tabur',
'tafakuran': 'tafakur',
'bertafakur': 'tafakur',
'menafakurkan': 'tafakur',
'tahanan': 'tahan',
'tahanannya': 'tahan',
'tahananlah': 'tahan',
'tahananan': 'tahan',
'tahananku': 'tahan',
'tahananmu': 'tahan',
'penahan': 'tahan',
'penahannya': 'tahan',
'penahanan': 'tahan',
'menahan': 'tahan',
'menahannya': 'tahan',
'menahankan': 'tahan',
'menahankannya': 'tahan',
'menahanan': 'tahan',
'menahanku': 'tahan',
'menahanmu': 'tahan',
'menahani': 'tahan',
'bertahan': 'tahan',
'bertahannya': 'tahan',
'bertahanlah': 'tahan',
'bertahankan': 'tahan',
'bertahani': 'tahan',
'bertahanan': 'tahan',
'tertahan': 'tahan',
'tertahannya': 'tahan',
'tertahankan': 'tahan',
'tertahanan': 'tahan',
'penahanannya': 'tahan',
'penahananan': 'tahan',
'penahananku': 'tahan',
'ketahanan': 'tahan',
'ketahanannya': 'tahan',
'ketahananan': 'tahan',
'pertahanan': 'tahan',
'pertahanannya': 'tahan',
'pertahananlah': 'tahan',
'pertahanankan': 'tahan',
'pertahananan': 'tahan',
'pertahananku': 'tahan',
'mempertahankan': 'tahan',
'mempertahankannya': 'tahan',
'mempertahankankan': 'tahan',
'mempertahankanku': 'tahan',
'bertahan-tahan': 'tahan',
'tertahan-tahan': 'tahan',
'bertakwa': 'takwa',
'bertakwalah': 'takwa',
'ketakwaan': 'takwa',
'ketakwaannya': 'takwa',
'bertanah': 'tanah',
'pertanahan': 'tanah',
'pertanahannya': 'tanah',
'pertanahanan': 'tanah',
'mengetanahkan': 'tanah',
'menanduk': 'tanduk',
'menanduknya': 'tanduk',
'menandukkan': 'tanduk',
'menandukkannya': 'tanduk',
'menandukan': 'tanduk',
'menandukku': 'tanduk',
'tandukan': 'tanduk',
'tandukannya': 'tanduk',
'tandukanku': 'tanduk',
'bertanduk': 'tanduk',
'tanganan': 'tangan',
'tanganannya': 'tangan',
'menangani': 'tangan',
'menanganinya': 'tangan',
'menanganiku': 'tangan',
'bertangan': 'tangan',
'tertangani': 'tangan',
'tertanganinya': 'tangan',
'penanganan': 'tangan',
'penanganannya': 'tangan',
'penangananlah': 'tangan',
'penangananan': 'tangan',
'tangan-tangan': 'tangan',
'tangan-tangannya': 'tangan',
'tangan-tanganku': 'tangan',
'tangan-tanganmu': 'tangan',
'tangan-menangan': 'tangan',
'tertanggal': 'tanggal',
'menanggali': 'tanggal',
'bertanggal': 'tanggal',
'bertanggalkan': 'tanggal',
'bertanggalan': 'tanggal',
'penanggalan': 'tanggal',
'penanggalannya': 'tanggal',
'menanggalkan': 'tanggal',
'menanggalkannya': 'tanggal',
'menanggam': 'tanggam',
'menanggami': 'tanggam',
'bertanggam': 'tanggam',
'bertangguh': 'tangguh',
'tertangguh': 'tangguh',
'tertangguhnya': 'tangguh',
'tertangguhkan': 'tangguh',
'ketangguhan': 'tangguh',
'ketangguhannya': 'tangguh',
'penangguhan': 'tangguh',
'penangguhannya': 'tangguh',
'penangguhanan': 'tangguh',
'pertangguhan': 'tangguh',
'menangguhkan': 'tangguh',
'menangguhkannya': 'tangguh',
'mempertangguhkan': 'tangguh',
'menanya': 'tanya',
'menanyanya': 'tanya',
'menanyakan': 'tanya',
'menanyakannya': 'tanya',
'menanyai': 'tanya',
'menanyaan': 'tanya',
'penanya': 'tanya',
'penanyanya': 'tanya',
'bertanya': 'tanya',
'bertanyanya': 'tanya',
'bertanyalah': 'tanya',
'bertanyaan': 'tanya',
'menanyainya': 'tanya',
'menanyaiku': 'tanya',
'penanyaan': 'tanya',
'pertanyaan': 'tanya',
'pertanyaannya': 'tanya',
'pertanyaanlah': 'tanya',
'pertanyaanan': 'tanya',
'pertanyaanku': 'tanya',
'pertanyaanmu': 'tanya',
'menanyakanan': 'tanya',
'menanyakanku': 'tanya',
'menanyakanmu': 'tanya',
'mempertanyakan': 'tanya',
'mempertanyakannya': 'tanya',
'bertanya-tanya': 'tanya',
'petapa': 'tapa',
'petapaan': 'tapa',
'pertapa': 'tapa',
'pertapakan': 'tapa',
'pertapaan': 'tapa',
'bertapa': 'tapa',
'bertapanya': 'tapa',
'tapa-tapa': 'tapa',
'pertapaannya': 'tapa',
'mempertapakan': 'tapa',
'menapak': 'tapak',
'menapakkan': 'tapak',
'menapaki': 'tapak',
'menapakan': 'tapak',
'setapak': 'tapak',
'setapaknya': 'tapak',
'bertapak': 'tapak',
'menapakinya': 'tapak',
'ketapakan': 'tapak',
'bertapakkan': 'tapak',
'tapak-tapak': 'tapak',
'menaruh': 'taruh',
'menaruhnya': 'taruh',
'menaruhkan': 'taruh',
'menaruhku': 'taruh',
'petaruh': 'taruh',
'petaruhnya': 'taruh',
'petaruhan': 'taruh',
'taruhan': 'taruh',
'taruhannya': 'taruh',
'bertaruh': 'taruh',
'bertaruhlah': 'taruh',
'bertaruhan': 'taruh',
'menaruhi': 'taruh',
'pertaruhan': 'taruh',
'pertaruhannya': 'taruh',
'pertaruhanlah': 'taruh',
'berpetaruh': 'taruh',
'berpenaruhan': 'taruh',
'mempertaruhkan': 'taruh',
'mempertaruhkannya': 'taruh',
'penarung': 'tarung',
'penarungan': 'tarung',
'menarung': 'tarung',
'menarungkan': 'tarung',
'menarungi': 'tarung',
'bertarung': 'tarung',
'bertarungnya': 'tarung',
'bertarunglah': 'tarung',
'bertarungi': 'tarung',
'bertarungan': 'tarung',
'tertarung': 'tarung',
'tertarungan': 'tarung',
'pertarungan': 'tarung',
'pertarungannya': 'tarung',
'pertarunganku': 'tarung',
'mempertarungkan': 'tarung',
'mempertarungkannya': 'tarung',
'menatah': 'tatah',
'tatahan': 'tatah',
'bertatah': 'tatah',
'bertatahnya': 'tatah',
'bertatahkan': 'tatah',
'tatah-tatah': 'tatah',
'tautan': 'taut',
'tautannya': 'taut',
'bertaut': 'taut',
'bertautnya': 'taut',
'bertautkan': 'taut',
'bertautan': 'taut',
'menautkan': 'taut',
'menautkannya': 'taut',
'pertautan': 'taut',
'mempertautkan': 'taut',
'bertekad': 'tekad',
'bertekadlah': 'tekad',
'menekuni': 'tekun',
'menekuninya': 'tekun',
'tertekun': 'tekun',
'bertekun': 'tekun',
'ketekunan': 'tekun',
'ketekunannya': 'tekun',
'ketekunanan': 'tekun',
'menekunkan': 'tekun',
'bertelanjang': 'telanjang',
'bertelanjanglah': 'telanjang',
'menelanjangi': 'telanjang',
'menelanjanginya': 'telanjang',
'penelanjangan': 'telanjang',
'ketelanjangan': 'telanjang',
'ketelanjangannya': 'telanjang',
'menelanjangkan': 'telanjang',
'petelur': 'telur',
'petelurnya': 'telur',
'menelur': 'telur',
'menelurkan': 'telur',
'menelurkannya': 'telur',
'bertelur': 'telur',
'bertelurnya': 'telur',
'peneluran': 'telur',
'perteluran': 'telur',
'menelut': 'telut',
'menelutkan': 'telut',
'bertelut': 'telut',
'peneman': 'teman',
'menemani': 'teman',
'menemaninya': 'teman',
'menemaniku': 'teman',
'menemanimu': 'teman',
'berteman': 'teman',
'bertemannya': 'teman',
'bertemanlah': 'teman',
'bertemankan': 'teman',
'bertemanan': 'teman',
'pertemanan': 'teman',
'pertemanannya': 'teman',
'pertemananlah': 'teman',
'pertemananmu': 'teman',
'menembung': 'tembung',
'bertembung': 'tembung',
'pertembungan': 'tembung',
'menempel': 'tempel',
'menempelnya': 'tempel',
'menempelkan': 'tempel',
'menempelkannya': 'tempel',
'menempeli': 'tempel',
'tempelan': 'tempel',
'tempelannya': 'tempel',
'penempel': 'tempel',
'penempelkan': 'tempel',
'penempelan': 'tempel',
'menempelinya': 'tempel',
'bertempel': 'tempel',
'bertempelan': 'tempel',
'penempelannya': 'tempel',
'menempur': 'tempur',
'tempuran': 'tempur',
'penempur': 'tempur',
'bertempur': 'tempur',
'bertempurnya': 'tempur',
'bertempurlah': 'tempur',
'bertempuran': 'tempur',
'pertempuran': 'tempur',
'pertempurannya': 'tempur',
'mempertempurkan': 'tempur',
'temuan': 'temu',
'temuannya': 'temu',
'temuanlah': 'temu',
'temuanku': 'temu',
'menemu': 'temu',
'menemunya': 'temu',
'menemukan': 'temu',
'menemukannya': 'temu',
'menemui': 'temu',
'menemuan': 'temu',
'penemu': 'temu',
'penemunya': 'temu',
'penemukan': 'temu',
'penemui': 'temu',
'penemuan': 'temu',
'menemuinya': 'temu',
'menemuikan': 'temu',
'menemuii': 'temu',
'menemuiku': 'temu',
'menemuimu': 'temu',
'bertemu': 'temu',
'bertemunya': 'temu',
'bertemulah': 'temu',
'bertemui': 'temu',
'bertemuan': 'temu',
'penemuannya': 'temu',
'penemuanlah': 'temu',
'pertemuan': 'temu',
'pertemuannya': 'temu',
'pertemuanan': 'temu',
'pertemuanku': 'temu',
'pertemuanmu': 'temu',
'menemukanlah': 'temu',
'menemukani': 'temu',
'menemukanan': 'temu',
'menemukanku': 'temu',
'menemukanmu': 'temu',
'tertemukan': 'temu',
'mempertemukan': 'temu',
'mempertemukannya': 'temu',
'mempertemukanmu': 'temu',
'menenagai': 'tenaga',
'bertenaga': 'tenaga',
'bertenaganya': 'tenaga',
'bertenagakan': 'tenaga',
'ketenagaan': 'tenaga',
'penenggek': 'tenggek',
'menenggek': 'tenggek',
'tenggekan': 'tenggek',
'bertenggek': 'tenggek',
'tertenggek': 'tenggek',
'menenggekkan': 'tenggek',
'tenggeran': 'tengger',
'bertengger': 'tengger',
'bertenggernya': 'tengger',
'bertenggerlah': 'tengger',
'bertenggeri': 'tengger',
'penengkar': 'tengkar',
'menengkar': 'tengkar',
'menengkari': 'tengkar',
'bertengkar': 'tengkar',
'bertengkarnya': 'tengkar',
'bertengkaran': 'tengkar',
'menengkarkan': 'tengkar',
'pertengkaran': 'tengkar',
'pertengkarannya': 'tengkar',
'mempertengkarkan': 'tengkar',
'tentangan': 'tentang',
'tentangannya': 'tentang',
'setentang': 'tentang',
'penentang': 'tentang',
'penentangnya': 'tentang',
'penentangan': 'tentang',
'menentang': 'tentang',
'menentangnya': 'tentang',
'menentangku': 'tentang',
'menentangmu': 'tentang',
'menentangi': 'tentang',
'bertentang': 'tentang',
'bertentangan': 'tentang',
'tertentang': 'tentang',
'tertentangan': 'tentang',
'penentangannya': 'tentang',
'penentanganan': 'tentang',
'menentangkan': 'tentang',
'bertentangannya': 'tentang',
'bertentanganlah': 'tentang',
'pertentangan': 'tentang',
'pertentangannya': 'tentang',
'mempertentangkan': 'tentang',
'mempertentangkannya': 'tentang',
'menepung': 'tepung',
'bertepung': 'tepung',
'teriakan': 'teriak',
'teriakannya': 'teriak',
'teriakanlah': 'teriak',
'teriakanku': 'teriak',
'teriakanmu': 'teriak',
'meneriaki': 'teriak',
'meneriakinya': 'teriak',
'meneriakiku': 'teriak',
'meneriakimu': 'teriak',
'berteriak': 'teriak',
'berteriaknya': 'teriak',
'berteriaklah': 'teriak',
'berteriakan': 'teriak',
'meneriakkan': 'teriak',
'meneriakkannya': 'teriak',
'berteriak-teriak': 'teriak',
'berterus terang': 'terus terang',
'bertetangga': 'tetangga',
'bertetanggaan': 'tetangga',
'bertiang': 'tiang',
'menikai': 'tikai',
'tikaian': 'tikai',
'bertikai': 'tikai',
'bertikainya': 'tikai',
'bertikaii': 'tikai',
'bertikaian': 'tikai',
'pertikaian': 'tikai',
'pertikaiannya': 'tikai',
'mempertikaikan': 'tikai',
'menindak': 'tindak',
'menindaknya': 'tindak',
'menindakkan': 'tindak',
'menindaki': 'tindak',
'menindakan': 'tindak',
'tindakan': 'tindak',
'tindakannya': 'tindak',
'tindakanlah': 'tindak',
'tindakankannya': 'tindak',
'tindakanan': 'tindak',
'tindakanku': 'tindak',
'tindakanmu': 'tindak',
'tindakan-ku': 'tindak',
'bertindak': 'tindak',
'bertindaknya': 'tindak',
'bertindaklah': 'tindak',
'bertindakan': 'tindak',
'penindakan': 'tindak',
'penindakannya': 'tindak',
'penindakanlah': 'tindak',
'meningkah': 'tingkah',
'meningkahi': 'tingkah',
'peningkah': 'tingkah',
'bertingkah': 'tingkah',
'bertingkah-tingkah': 'tingkah',
'setingkat': 'tingkat',
'setingkatnya': 'tingkat',
'tingkatan': 'tingkat',
'tingkatannya': 'tingkat',
'meningkat': 'tingkat',
'meningkatnya': 'tingkat',
'meningkatlah': 'tingkat',
'meningkatkan': 'tingkat',
'meningkatkannya': 'tingkat',
'meningkatan': 'tingkat',
'bertingkat': 'tingkat',
'bertingkatnya': 'tingkat',
'bertingkatlah': 'tingkat',
'bertingkatkan': 'tingkat',
'peningkatan': 'tingkat',
'peningkatannya': 'tingkat',
'peningkatanlah': 'tingkat',
'peningkatankan': 'tingkat',
'peningkatanan': 'tingkat',
'meningkatkankan': 'tingkat',
'meningkat-ningkat': 'tingkat',
'bertingkat-tingkat': 'tingkat',
'menokoh': 'tokoh',
'menokohkan': 'tokoh',
'penokoh': 'tokoh',
'penokohan': 'tokoh',
'menokohi': 'tokoh',
'bertokoh': 'tokoh',
'bertokohkan': 'tokoh',
'penokohannya': 'tokoh',
'ketokohan': 'tokoh',
'ketokohannya': 'tokoh',
'pertokohan': 'tokoh',
'menolak': 'tolak',
'menolaknya': 'tolak',
'menolaklah': 'tolak',
'menolakkan': 'tolak',
'menolaki': 'tolak',
'menolakan': 'tolak',
'menolakku': 'tolak',
'menolakmu': 'tolak',
'tolakan': 'tolak',
'tolakannya': 'tolak',
'penolak': 'tolak',
'penolaknya': 'tolak',
'penolakkan': 'tolak',
'penolakkannya': 'tolak',
'penolakan': 'tolak',
'tertolak': 'tolak',
'tertolaknya': 'tolak',
'bertolak': 'tolak',
'bertolaknya': 'tolak',
'bertolaklah': 'tolak',
'penolakannya': 'tolak',
'penolakanlah': 'tolak',
'tolak-menolak': 'tolak',
'bertolak-tolak': 'tolak',
'bertolak-tolakan': 'tolak',
'menoleransi': 'toleransi',
'menoleransinya': 'toleransi',
'bertoleransi': 'toleransi',
'menopengi': 'topeng',
'bertopeng': 'topeng',
'bertopengnya': 'topeng',
'bertopengkan': 'topeng',
'mempertopeng': 'topeng',
'menuahi': 'tuah',
'bertuah': 'tuah',
'bertuahnya': 'tuah',
'ketuahan': 'tuah',
'ketuahanan': 'tuah',
'menuahkan': 'tuah',
'bertuhan': 'tuhan',
'ketuhanan': 'tuhan',
'ketuhanannya': 'tuhan',
'ketuhananan': 'tuhan',
'menuhankan': 'tuhan',
'mempertuhan': 'tuhan',
'mempertuhankan': 'tuhan',
'bertuhankan': 'tuhan',
'menukangi': 'tukang',
'menukanginya': 'tukang',
'bertukang': 'tukang',
'ketukangan': 'tukang',
'pertukangan': 'tukang',
'tukang-menukang': 'tukang',
'menukar': 'tukar',
'menukarnya': 'tukar',
'menukarkan': 'tukar',
'menukarkannya': 'tukar',
'menukaran': 'tukar',
'penukar': 'tukar',
'penukarnya': 'tukar',
'penukarkan': 'tukar',
'penukaran': 'tukar',
'bertukar': 'tukar',
'bertukarnya': 'tukar',
'bertukarlah': 'tukar',
'bertukaran': 'tukar',
'tertukar': 'tukar',
'tertukarnya': 'tukar',
'menukari': 'tukar',
'penukarannya': 'tukar',
'pertukaran': 'tukar',
'pertukarannya': 'tukar',
'tukar-menukar': 'tukar',
'mempertukarkan': 'tukar',
'mempertukarkannya': 'tukar',
'bertukar-tukar': 'tukar',
'bertukar-tukaran': 'tukar',
'penulis': 'tulis',
'penulisnya': 'tulis',
'penulislah': 'tulis',
'penulisan': 'tulis',
'tulisan': 'tulis',
'tulisannya': 'tulis',
'tulisanlah': 'tulis',
'tulisanku': 'tulis',
'tulisanmu': 'tulis',
'menulis': 'tulis',
'menulisnya': 'tulis',
'menulislah': 'tulis',
'menuliskan': 'tulis',
'menuliskannya': 'tulis',
'menulisi': 'tulis',
'menulisan': 'tulis',
'menulismu': 'tulis',
'bertulis': 'tulis',
'bertuliskan': 'tulis',
'bertulisan': 'tulis',
'menulisinya': 'tulis',
'menulisikan': 'tulis',
'menulisiku': 'tulis',
'tertulis': 'tulis',
'tertulisnya': 'tulis',
'tertulislah': 'tulis',
'tertuliskan': 'tulis',
'tertulisan': 'tulis',
'penulisannya': 'tulis',
'penulisanmu': 'tulis',
'menuliskankan': 'tulis',
'tulis-menulis': 'tulis',
'menumbuk': 'tumbuk',
'menumbuknya': 'tumbuk',
'menumbukkan': 'tumbuk',
'menumbukan': 'tumbuk',
'penumbuk': 'tumbuk',
'penumbukan': 'tumbuk',
'tumbukan': 'tumbuk',
'tumbukannya': 'tumbuk',
'tertumbuk': 'tumbuk',
'bertumbuk': 'tumbuk',
'bertumbuknya': 'tumbuk',
'bertumbukkan': 'tumbuk',
'bertumbukan': 'tumbuk',
'ketumbukan': 'tumbuk',
'penumpu': 'tumpu',
'penumpukan': 'tumpuk',
'penumpukannya': 'tumpuk',
'setumpu': 'tumpu',
'setumpukan': 'tumpuk',
'menumpu': 'tumpu',
'menumpukan': 'tumpuk',
'tumpuan': 'tumpu',
'tumpuannya': 'tumpu',
'bertumpu': 'tumpu',
'bertumpunya': 'tumpu',
'bertumpulah': 'tumpu',
'bertumpukan': 'tumpu',
'tertumpu': 'tumpu',
'bersetumpu': 'tumpu',
'menurap': 'turap',
'menurapnya': 'turap',
'berturap': 'turap',
'tuturan': 'tutur',
'tuturannya': 'tutur',
'penutur': 'tutur',
'penuturnya': 'tutur',
'penuturkan': 'tutur',
'penuturan': 'tutur',
'bertutur': 'tutur',
'bertuturnya': 'tutur',
'bertuturkan': 'tutur',
'tertutur': 'tutur',
'petuturan': 'tutur',
'penuturannya': 'tutur',
'penuturanmu': 'tutur',
'pertuturan': 'tutur',
'menuturkan': 'tutur',
'menuturkannya': 'tutur',
'menuturkankan': 'tutur',
'bertutur-tutur': 'tutur',
'mempertuturkan': 'tutur',
'beruang': 'uang',
'beruangnya': 'uang',
'beruanglah': 'uang',
'beruangan': 'uang',
'keuangan': 'uang',
'keuangannya': 'uang',
'keuanganlah': 'uang',
'keuanganan': 'uang',
'keuanganku': 'uang',
'keuanganmu': 'uang',
'menguangi': 'uang',
'peruangan': 'uang',
'penguangan': 'uang',
'penguangannya': 'uang',
'uang-uangan': 'uang',
'menguangkan': 'uang',
'menguangkannya': 'uang',
'peubah': 'ubah',
'peubahnya': 'ubah',
'peubahan': 'ubah',
'ubahan': 'ubah',
'ubahannya': 'ubah',
'terubah': 'ubah',
'perubah': 'ubah',
'perubahkan': 'ubah',
'perubahan': 'ubah',
'berubah': 'ubah',
'berubahnya': 'ubah',
'berubahlah': 'ubah',
'berubahan': 'ubah',
'pengubah': 'ubah',
'pengubahnya': 'ubah',
'pengubahan': 'ubah',
'mengubah': 'ubah',
'mengubahnya': 'ubah',
'mengubahkan': 'ubah',
'mengubahan': 'ubah',
'mengubahku': 'ubah',
'mengubahmu': 'ubah',
'perubahannya': 'ubah',
'perubahanlah': 'ubah',
'perubahanan': 'ubah',
'perubahanku': 'ubah',
'pengubahannya': 'ubah',
'berubah-ubah': 'ubah',
'berubah-ubahnya': 'ubah',
'memperubahkan': 'ubah',
'ubanan': 'uban',
'beruban': 'uban',
'berubannya': 'uban',
'menguban': 'uban',
'mengubani': 'uban',
'berudu': 'udu',
'berudunya': 'udu',
'ukiran': 'ukir',
'ukirannya': 'ukir',
'terukir': 'ukir',
'terukirnya': 'ukir',
'terukirlah': 'ukir',
'terukirkan': 'ukir',
'berukir': 'ukir',
'berukirkan': 'ukir',
'berukiran': 'ukir',
'mengukir': 'ukir',
'mengukirnya': 'ukir',
'mengukirkan': 'ukir',
'mengukirkannya': 'ukir',
'pengukir': 'ukir',
'pengukiran': 'ukir',
'mengukiri': 'ukir',
'pengukirannya': 'ukir',
'ukir-ukiran': 'ukir',
'ukir-mengukir': 'ukir',
'seukur': 'ukur',
'seukuran': 'ukur',
'ukuran': 'ukur',
'ukurannya': 'ukur',
'ukuranlah': 'ukur',
'ukuranku': 'ukur',
'ukuranmu': 'ukur',
'mengukur': 'ukur',
'mengukurnya': 'ukur',
'mengukurlah': 'ukur',
'mengukurkan': 'ukur',
'mengukurkannya': 'ukur',
'pengukur': 'ukur',
'pengukurnya': 'ukur',
'pengukuran': 'ukur',
'berukuran': 'ukur',
'berukurannya': 'ukur',
'pengukurannya': 'ukur',
'ulangan': 'ulang',
'ulangannya': 'ulang',
'ulangani': 'ulang',
'seulang': 'ulang',
'berulang': 'ulang',
'berulangnya': 'ulang',
'berulanglah': 'ulang',
'berulangkan': 'ulang',
'terulang': 'ulang',
'terulangnya': 'ulang',
'terulangkan': 'ulang',
'terulangi': 'ulang',
'pengulang': 'ulang',
'pengulangan': 'ulang',
'mengulang': 'ulang',
'mengulangnya': 'ulang',
'mengulangi': 'ulang',
'mengulanginya': 'ulang',
'perulangan': 'ulang',
'perulangannya': 'ulang',
'pengulangannya': 'ulang',
'ulang-ulang': 'ulang',
'ulang-ulangi': 'ulang',
'berulang-ulang': 'ulang',
'berulang-ulangnya': 'ulang',
'mengulang-ulang': 'ulang',
'mengulang-ulangnya': 'ulang',
'mengulang-ulangi': 'ulang',
'berulat': 'ulat',
'terberumbun': 'berumbun',
'berumput': 'umput',
'seumur': 'umur',
'seumurnya': 'umur',
'seumuran': 'umur',
'seumurmu': 'umur',
'berumur': 'umur',
'berumurnya': 'umur',
'berumuran': 'umur',
'rundingan': 'runding',
'rundingannya': 'runding',
'berunding': 'runding',
'berundingnya': 'runding',
'berundinglah': 'runding',
'berundingan': 'runding',
'merunding': 'runding',
'merundingkan': 'runding',
'merundingkannya': 'runding',
'merundingan': 'runding',
'perunding': 'berunding',
'perundingnya': 'berunding',
'perundingkan': 'berunding',
'perundingan': 'berunding',
'perundingannya': 'berunding',
'perundinganlah': 'berunding',
'perundinganan': 'berunding',
'memperundingkan': 'runding',
'rungutan': 'rungut',
'merungut': 'rungut',
'berungut': 'rungut',
'berungutan': 'rungut',
'merungutkan': 'rungut',
'merungut-rungut': 'rungut',
'berunsur': 'unsur',
'berunsurkan': 'unsur',
'beruntung': 'untung',
'beruntungnya': 'untung',
'beruntunglah': 'untung',
'beruntungan': 'untung',
'keuntungan': 'untung',
'keuntungannya': 'untung',
'keuntunganlah': 'untung',
'keuntunganku': 'untung',
'peruntungan': 'untung',
'peruntungannya': 'untung',
'peruntunganlah': 'untung',
'peruntunganku': 'untung',
'peruntunganmu': 'untung',
'untung-untung': 'untung',
'untung-untungan': 'untung',
'menguntungkan': 'untung',
'menguntungkannya': 'untung',
'menguntungkanlah': 'untung',
'menguntungkankan': 'untung',
'menguntungkanku': 'untung',
'menguntungkanmu': 'untung',
'keberuntungan': 'untung',
'keberuntungannya': 'untung',
'keberuntunganlah': 'untung',
'keberuntunganku': 'untung',
'keberuntunganmu': 'untung',
'beruntung-untung': 'untung',
'seberuntung-beruntungnya': 'untung',
'beruntusan': 'beruntus',
'perupa': 'rupa',
'perupakan': 'rupa',
'perupaan': 'rupa',
'serupa': 'rupa',
'serupanya': 'rupa',
'serupalah': 'rupa',
'berupa': 'rupa',
'berupanya': 'rupa',
'berupakan': 'rupa',
'berupai': 'rupa',
'terupa': 'rupa',
'terupakan': 'rupa',
'merupa': 'rupa',
'merupakan': 'rupa',
'merupai': 'rupa',
'merupaan': 'rupa',
'rupanya': 'rupa',
'rupanyanya': 'rupa',
'merupakani': 'rupa',
'merupakanan': 'rupa',
'berserupa': 'rupa',
'rupa-rupa': 'rupa',
'rupa-rupanya': 'rupa',
'menyerupa': 'rupa',
'menyerupakan': 'rupa',
'menyerupai': 'rupa',
'keserupaan': 'rupa',
'menyerupainya': 'rupa',
'menyerupaian': 'rupa',
'berupa-rupa': 'rupa',
'perserupaan': 'rupa',
'urutan': 'urut',
'urutannya': 'urut',
'berurut': 'urut',
'berurutlah': 'urut',
'berurutan': 'urut',
'mengurut': 'urut',
'mengurutnya': 'urut',
'mengurutkan': 'urut',
'mengurutkannya': 'urut',
'menguruti': 'urut',
'pengurutan': 'urut',
'memperurutkan': 'urut',
'berurut-urutan': 'urut',
'memberus': 'berus',
'berusaha': 'usaha',
'berusahanya': 'usaha',
'berusahalah': 'usaha',
'berusahakan': 'usaha',
'berusahaan': 'usaha',
'pengusaha': 'usaha',
'pengusahanya': 'usaha',
'pengusahalah': 'usaha',
'pengusahaan': 'usaha',
'perusahaan': 'usaha',
'perusahaannya': 'usaha',
'perusahaanlah': 'usaha',
'perusahaankan': 'usaha',
'perusahaanku': 'usaha',
'perusahaanmu': 'usaha',
'pengusahaannya': 'usaha',
'mengusahakan': 'usaha',
'mengusahakannya': 'usaha',
'kepengusahaan': 'usaha',
'berusia': 'usia',
'berusianya': 'usia',
'berusiai': 'usia',
'sewarna': 'warna',
'pewarna': 'warna',
'pewarnanya': 'warna',
'pewarnaan': 'warna',
'mewarnai': 'warna',
'mewarnainya': 'warna',
'berwarna': 'warna',
'berwarnanya': 'warna',
'berwarnakan': 'warna',
'berwarnai': 'warna',
'pewarnaannya': 'warna',
'mewarnakan': 'warna',
'berwarna-warna': 'warna',
'berwarna-warnai': 'warna',
'berwasiat': 'wasiat',
'mewasiatkan': 'wasiat',
'berwibawa': 'wibawa',
'berwibawanya': 'wibawa',
'kewibawaan': 'wibawa',
'kewibawaannya': 'wibawa',
'peziarah': 'ziarah',
'peziarahnya': 'ziarah',
'peziarahan': 'ziarah',
'penziarah': 'ziarah',
'penziarahnya': 'ziarah',
'penziarahan': 'ziarah',
'berziarah': 'ziarah',
'berziarahlah': 'ziarah',
'menziarahi': 'ziarah',
'menziarahinya': 'ziarah',
'menziarahiku': 'ziarah',
'berzina': 'zina',
'menzinai': 'zina',
'perzinaan': 'zina',
'perzinaannya': 'zina',
'berbesan': 'besan',
'berbesanan': 'besan',
'berbesar hati': 'besar hati',
'kebesar-hatian': 'besar hati',
'terbesar': 'besar',
'terbesarnya': 'besar',
'terbesarlah': 'besar',
'terbesarkan': 'besar',
'terbesari': 'besar',
'terbesarku': 'besar',
'terbesarmu': 'besar',
'pembesar': 'besar',
'pembesarnya': 'besar',
'pembesaran': 'besar',
'membesar': 'besar',
'membesarnya': 'besar',
'membesarkan': 'besar',
'membesarkannya': 'besar',
'membesaran': 'besar',
'kebesaran': 'besar',
'kebesarannya': 'besar',
'kebesaranmu': 'besar',
'kebesaran-mu': 'besar',
'pembesarannya': 'besar',
'membesarkanku': 'besar',
'membesarkanmu': 'besar',
'memperbesar': 'besar',
'memperbesarnya': 'besar',
'memperbesarkan': 'besar',
'besar-besaran': 'besar',
'besar-besarannya': 'besar',
'besar-besaranlah': 'besar',
'besar-besaranan': 'besar',
'membesar-besar': 'besar',
'membesar-besarnya': 'besar',
'membesar-besarkan': 'besar',
'membesar-besarkannya': 'besar',
'membesar-besaran': 'besar',
'berbesar-besar': 'besar',
'beselan': 'besel',
'membeset': 'beset',
'membesi': 'besi',
'membesi tua': 'besi tua',
'membesituakan': 'besi tua',
'terbesit': 'besit',
'terbesitlah': 'besit',
'membesit': 'besit',
'membesitkan': 'besit',
'beslahan': 'beslah',
'membeslah': 'beslah',
'pembeslahan': 'beslah',
'bestelan': 'bestel',
'membestel': 'bestel',
'pembestralan': 'bestral',
'membesut': 'besut',
'membesutnya': 'besut',
'membesutkan': 'besut',
'berbeta': 'beta',
'membetahkan': 'betah',
'membetas': 'betas',
'penernak': 'ternak',
'peternak': 'ternak',
'peternaknya': 'ternak',
'peternakkan': 'ternak',
'peternakan': 'ternak',
'beternak': 'ternak',
'beternaknya': 'ternak',
'peternakannya': 'ternak',
'menernakkan': 'ternak',
'menernakkannya': 'ternak',
'terbeti': 'beti',
'terbetik': 'betik',
'terbetiknya': 'betik',
'betik-betik': 'betik',
'membeting': 'beting',
'berbeting': 'beting',
'terbeting': 'beting',
'membeton': 'beton',
'membetonnya': 'beton',
'membetoni': 'beton',
'membetot': 'betot',
'betulan': 'betul',
'betulannya': 'betul',
'berbetul': 'betul',
'kebetulan': 'betul',
'kebetulannya': 'betul',
'kebetulankan': 'betul',
'membetuli': 'betul',
'sebetulnya': 'betul',
'berbetulan': 'betul',
'pembetulan': 'betul',
'pembetulannya': 'betul',
'membetulkan': 'betul',
'membetulkannya': 'betul',
'betul-betul': 'betul',
'berkebetulan': 'betul',
'kebiadaban': 'biadab',
'kebiadabannya': 'biadab',
'membiadabi': 'biadab',
'biakan': 'biak',
'biakannya': 'biak',
'membiak': 'biak',
'membiaknya': 'biak',
'membiakkan': 'biak',
'membiakkannya': 'biak',
'membiakan': 'biak',
'berbiak': 'biak',
'berbiaknya': 'biak',
'membiaki': 'biak',
'pembiakan': 'biak',
'pembiakannya': 'biak',
'biang biut': 'biang',
'biang-biang': 'biang',
'memperbiar': 'biar',
'membiarkan': 'biar',
'membiarkannya': 'biar',
'membiarkankan': 'biar',
'membiarkanku': 'biar',
'membiarkanmu': 'biar',
'membias': 'bias',
'membiaskan': 'bias',
'pembiasan': 'bias',
'pembiasannya': 'bias',
'biasanya': 'biasa',
'biasanyanya': 'biasa',
'biasanyalah': 'biasa',
'biasanyakan': 'biasa',
'terbiasa': 'biasa',
'terbiasanya': 'biasa',
'terbiasalah': 'biasa',
'terbiasai': 'biasa',
'kebiasaan': 'biasa',
'kebiasaannya': 'biasa',
'kebiasaanku': 'biasa',
'kebiasaanmu': 'biasa',
'membiasakan': 'biasa',
'membiasakannya': 'biasa',
'membiasakanmu': 'biasa',
'berbiau': 'biau',
'membiawak': 'biawak',
'membiayai': 'biaya',
'membiayainya': 'biaya',
'pembiayaan': 'biaya',
'pembiayaannya': 'biaya',
'membiayakan': 'biaya',
'pembibit': 'bibit',
'pembibitan': 'bibit',
'membibit': 'bibit',
'membibitkan': 'bibit',
'pembibitannya': 'bibit',
'membicu': 'bicu',
'bicu-bicu': 'bicu',
'membidai': 'bidai',
'berbidai-bidai': 'bidai',
'berbidan': 'bidan',
'kebidanan': 'bidan',
'kebidananan': 'bidan',
'membidani': 'bidan',
'bidangan': 'bidang',
'pembidang': 'bidang',
'pembidangan': 'bidang',
'membidangi': 'bidang',
'membidanginya': 'bidang',
'pembidangannya': 'bidang',
'membidangkan': 'bidang',
'bidasan': 'bidas',
'pembidas': 'bidas',
'membidas': 'bidas',
'bidikan': 'bidik',
'bidikannya': 'bidik',
'membidik': 'bidik',
'membidiknya': 'bidik',
'membidiklah': 'bidik',
'membidikkan': 'bidik',
'membidiki': 'bidik',
'membidikan': 'bidik',
'membidikku': 'bidik',
'pembidik': 'bidik',
'pembidiknya': 'bidik',
'pembidikan': 'bidik',
'berbiduk': 'biduk',
'berbiduk-biduk': 'biduk',
'kebijakan': 'bijak',
'kebijakannya': 'bijak',
'kebijakanlah': 'bijak',
'kebijakankan': 'bijak',
'kebijakanan': 'bijak',
'kebijakanku': 'bijak',
'kebijakanmu': 'bijak',
'kebijaksanaan': 'bijaksana',
'kebijaksanaannya': 'bijaksana',
'kebijaksanaanlah': 'bijaksana',
'berbiji': 'biji',
'membiji': 'biji',
'biji-bijian': 'biji',
'biji-bijiannya': 'biji',
'pembikangan': 'bikang',
'bikinan': 'bikin',
'bikinannya': 'bikin',
'terbikin': 'bikin',
'membikin': 'bikin',
'membikinnya': 'bikin',
'membikinkan': 'bikin',
'pembikinan': 'bikin',
'membikin-bikin': 'bikin',
'berbiku-biku': 'biku',
'bila-bila': 'bila',
'membilah-bilah': 'bilah',
'membilai': 'bilai',
'pembilas': 'bilas',
'pembilasan': 'bilas',
'membilas': 'bilas',
'membilasnya': 'bilas',
'berbilas': 'bilas',
'berbilik-bilik': 'bilik',
'kebimbangan': 'bimbang',
'kebimbangannya': 'bimbang',
'membimbangkan': 'bimbang',
'bimbingan': 'bimbing',
'bimbingannya': 'bimbing',
'pembimbing': 'bimbing',
'pembimbingnya': 'bimbing',
'pembimbingan': 'bimbing',
'pembimbingku': 'bimbing',
'pembimbingmu': 'bimbing',
'membimbing': 'bimbing',
'membimbingnya': 'bimbing',
'membimbinglah': 'bimbing',
'membimbingku': 'bimbing',
'membimbingmu': 'bimbing',
'berbimbing': 'bimbing',
'berbimbingan': 'bimbing',
'bimbitan': 'bimbit',
'membimbit': 'bimbit',
'membina': 'bina',
'membinanya': 'bina',
'membinakan': 'bina',
'membinaan': 'bina',
'pembina': 'bina',
'pembinanya': 'bina',
'pembinaan': 'bina',
'pembinamu': 'bina',
'pembinaannya': 'bina',
'pembinaanlah': 'bina',
'berbinar-binar': 'binar',
'kebinasaan': 'binasa',
'kebinasaannya': 'binasa',
'pembinasaan': 'binasa',
'membinasakan': 'binasa',
'membinasakannya': 'binasa',
'kebinatangan': 'binatang',
'kebinatangannya': 'binatang',
'berbincang': 'bincang',
'berbincangnya': 'bincang',
'berbincanglah': 'bincang',
'berbincangan': 'bincang',
'perbincangan': 'bincang',
'perbincangannya': 'bincang',
'perbincanganan': 'bincang',
'membincangkan': 'bincang',
'membincangkannya': 'bincang',
'berbincang-bincang': 'bincang',
'berbincang-bincanglah': 'bincang',
'membindu': 'bindu',
'kebinekaan': 'bineka',
'kebinekaannya': 'bineka',
'membingas': 'bingas',
'bingkahan': 'bingkah',
'membingkah': 'bingkah',
'membingkahi': 'bingkah',
'bingkah-bingkah': 'bingkah',
'berbingkah-bingkah': 'bingkah',
'membingkas': 'bingkas',
'bingkisan': 'bingkis',
'bingkisannya': 'bingkis',
'membingkis': 'bingkis',
'membingkisnya': 'bingkis',
'kebingungan': 'bingung',
'kebingungannya': 'bingung',
'membingungkan': 'bingung',
'membingungkannya': 'bingung',
'membinjat': 'binjat',
'berbintil-bintil': 'bintil',
'berbiola': 'biola',
'perbioskopan': 'bioskop',
'kebirahan': 'birah',
'berbiras': 'biras',
'terbirit': 'birit',
'terbirit-birit': 'birit',
'pembirokrasian': 'birokrasi',
'membiru': 'biru',
'membirunya': 'biru',
'membirukan': 'biru',
'kebiru-biruan': 'biru',
'kebiru-biruanan': 'biru',
'mengebiskan': 'bis',
'kebisingan': 'bising',
'kebisingannya': 'bising',
'membisingkan': 'bising',
'pebisnis': 'bisnis',
'pebisnisnya': 'bisnis',
'pebisnislah': 'bisnis',
'berbisnis': 'bisnis',
'berbisnisnya': 'bisnis',
'berbisnislah': 'bisnis',
'berbisniskan': 'bisnis',
'membisu': 'bisu',
'membisunya': 'bisu',
'membisukan': 'bisu',
'berbisu': 'bisu',
'membisul': 'bisul',
'berbisul': 'bisul',
'biti-biti': 'biti',
'terbius': 'bius',
'membius': 'bius',
'membiusnya': 'bius',
'membiuskan': 'bius',
'pembius': 'bius',
'pembiusnya': 'bius',
'pembiusan': 'bius',
'pembiusannya': 'bius',
'blasteran': 'blaster',
'blasterannya': 'blaster',
'memblaster': 'blaster',
'berblirik': 'blirik',
'memblokade': 'blokade',
'memblokadenya': 'blokade',
'pemblokadean': 'blokade',
'memblokir': 'blokir',
'memblokirnya': 'blokir',
'memblokiran': 'blokir',
'memblokirmu': 'blokir',
'membobok': 'bobok',
'memboboknya': 'bobok',
'membobol': 'bobol',
'membobolnya': 'bobol',
'membobolkan': 'bobol',
'pembobol': 'bobol',
'pembobolnya': 'bobol',
'pembobolan': 'bobol',
'kebobolan': 'bobol',
'kebobolannya': 'bobol',
'pembobolannya': 'bobol',
'membobos': 'bobos',
'berbobot': 'bobot',
'berbobotlah': 'bobot',
'kebobrokan': 'bobrok',
'kebobrokannya': 'bobrok',
'kebocahan': 'bocah',
'bocoran': 'bocor',
'bocorannya': 'bocor',
'kebocoran': 'bocor',
'kebocorannya': 'bocor',
'kebocoranlah': 'bocor',
'pembocoran': 'bocor',
'pembocorannya': 'bocor',
'membocorkan': 'bocor',
'membocorkannya': 'bocor',
'kebodohan': 'bodoh',
'kebodohannya': 'bodoh',
'kebodohanku': 'bodoh',
'kebodohanmu': 'bodoh',
'pembodohan': 'bodoh',
'pembodohanlah': 'bodoh',
'membodohkan': 'bodoh',
'memperbodoh': 'bodoh',
'bodoran': 'bodor',
'membodor': 'bodor',
'berboga': 'boga',
'memboikot': 'boikot',
'memboikotnya': 'boikot',
'pemboikot': 'boikot',
'pemboikotkan': 'boikot',
'pemboikotan': 'boikot',
'pemboikotannya': 'boikot',
'pembokong': 'bokong',
'membokong': 'bokong',
'pembokongan': 'bokong',
'membola': 'bola',
'berbolak-balik': 'bolak-balik',
'membolak-balikkan': 'bolak-balik',
'membolak-balikkannya': 'bolak-balik',
'bolehan': 'boleh',
'kebolehan': 'boleh',
'kebolehannya': 'boleh',
'membolehkan': 'boleh',
'membolehkannya': 'boleh',
'membolehkanku': 'boleh',
'membolehkanmu': 'boleh',
'memperbolehkan': 'boleh',
'memperbolehkannya': 'boleh',
'memperbolehkanku': 'boleh',
'seboleh-bolehnya': 'boleh',
'peboling': 'boling',
'berbolong-bolong': 'bolong',
'membolos': 'bolos',
'membolosnya': 'bolos',
'membolot': 'bolot',
'pengebom': 'bom',
'pengebomnya': 'bom',
'pengeboman': 'bom',
'mengebom': 'bom',
'mengebomnya': 'bom',
'mengebomi': 'bom',
'mengeboman': 'bom',
'pengebomannya': 'bom',
'pengebomanan': 'bom',
'membombardir': 'bombardir',
'membombardirnya': 'bombardir',
'mengebon': 'bon',
'boncengan': 'bonceng',
'boncengannya': 'bonceng',
'pembonceng': 'bonceng',
'pemboncengnya': 'bonceng',
'pemboncengan': 'bonceng',
'membonceng': 'bonceng',
'memboncengnya': 'bonceng',
'memboncengkan': 'bonceng',
'memboncengkannya': 'bonceng',
'memboncengi': 'bonceng',
'memboncengan': 'bonceng',
'berboncengan': 'bonceng',
'berbondong-bondong': 'bondong',
'berbondong-bondongnya': 'bondong',
'berbondong-bondonglah': 'bondong',
'membondot': 'bondot',
'membonekakan': 'boneka',
'memperboneka': 'boneka',
'memperbonekakan': 'boneka',
'membongak': 'bongak',
'membonggol': 'bonggol',
'membonggoli': 'bonggol',
'berbongkah': 'bongkah',
'membongkahi': 'bongkah',
'berbongkah-bongkah': 'bongkah',
'bongkaran': 'bongkar',
'bongkarannya': 'bongkar',
'terbongkar': 'bongkar',
'terbongkarnya': 'bongkar',
'terbongkarlah': 'bongkar',
'terbongkarkan': 'bongkar',
'membongkar': 'bongkar',
'membongkarnya': 'bongkar',
'membongkaran': 'bongkar',
'kebongkaran': 'bongkar',
'pembongkaran': 'bongkar',
'pembongkarannya': 'bongkar',
'membongkar-bongkar': 'bongkar',
'bongkar-membongkar': 'bongkar',
'membongkar-bangkir': 'bongkar-bangkir',
'membongmeh': 'bongmeh',
'membonsai': 'bonsai',
'membonsainya': 'bonsai',
'membonsaikan': 'bonsai',
'pembonsaian': 'bonsai',
'membopong': 'bopong',
'membopongnya': 'bopong',
'pengebor': 'bor',
'pengebornya': 'bor',
'pengeboran': 'bor',
'mengebor': 'bor',
'mengebornya': 'bor',
'mengeboran': 'bor',
'pengeborannya': 'bor',
'bordiran': 'bordir',
'bordirannya': 'bordir',
'membordir': 'bordir',
'membordirkan': 'bordir',
'memborgol': 'borgol',
'memborgolnya': 'borgol',
'memborgolkan': 'borgol',
'memborgolku': 'borgol',
'pemborgolan': 'borgol',
'borokan': 'borok',
'berborok': 'borok',
'memborok': 'borok',
'memborokan': 'borok',
'borongan': 'borong',
'borongannya': 'borong',
'memborong': 'borong',
'memborongnya': 'borong',
'memborongkan': 'borong',
'pemborong': 'borong',
'pemborongnya': 'borong',
'pemborongan': 'borong',
'pemboros': 'boros',
'pemborosan': 'boros',
'keborosan': 'boros',
'pemborosannya': 'boros',
'memboroskan': 'boros',
'memboroskannya': 'boros',
'pembosan': 'bosan',
'kebosanan': 'bosan',
'kebosanannya': 'bosan',
'kebosananku': 'bosan',
'membosankan': 'bosan',
'membosankannya': 'bosan',
'membotak': 'botak',
'membotakkan': 'botak',
'membotaki': 'botak',
'membotakinya': 'botak',
'kebotakan': 'botak',
'kebotakannya': 'botak',
'pembotolan': 'botol',
'pembotolannya': 'botol',
'memboya': 'boya',
'keboyakan': 'boyak',
'boyongan': 'boyong',
'boyongannya': 'boyong',
'berboyong': 'boyong',
'memboyong': 'boyong',
'memboyongnya': 'boyong',
'memboyongkan': 'boyong',
'memboyongan': 'boyong',
'memboyongku': 'boyong',
'pemboyongan': 'boyong',
'pembriketan': 'briket',
'kebrutalan': 'brutal',
'kebrutalannya': 'brutal',
'kebrutalanmu': 'brutal',
'berbuah': 'buah',
'berbuahnya': 'buah',
'berbuahlah': 'buah',
'berbuahkan': 'buah',
'bebuahan': 'buah',
'membuahi': 'buah',
'membuahinya': 'buah',
'perbuahan': 'buah',
'pembuahan': 'buah',
'pembuahannya': 'buah',
'membuahkan': 'buah',
'membuahkannya': 'buah',
'buah-buahan': 'buah',
'buah-buahannya': 'buah',
'buaian': 'buai',
'buaiannya': 'buai',
'terbuai': 'buai',
'terbuailah': 'buai',
'membuai': 'buai',
'membuainya': 'buai',
'membuaiku': 'buai',
'membuaimu': 'buai',
'berbuai': 'buai',
'berbuai-buai': 'buai',
'terbuai-buai': 'buai',
'membuak': 'buak',
'membuakan': 'buak',
'membuana': 'buana',
'buangan': 'buang',
'buangannya': 'buang',
'terbuang': 'buang',
'terbuangnya': 'buang',
'terbuanglah': 'buang',
'membuang': 'buang',
'membuangnya': 'buang',
'membuangkan': 'buang',
'membuangan': 'buang',
'membuangmu': 'buang',
'pembuangan': 'buang',
'pembuangannya': 'buang',
'terbuang-buang': 'buang',
'membuang-buang': 'buang',
'membuang-buangnya': 'buang',
'buang-buang air': 'buang',
'membuas': 'buas',
'membuaskan': 'buas',
'kebuasan': 'buas',
'kebuasannya': 'buas',
'membuaya': 'buaya',
'membuayai': 'buaya',
'pembubaran': 'bubar',
'pembubarannya': 'bubar',
'membubarkan': 'bubar',
'membubarkannya': 'bubar',
'membubu': 'bubu',
'membubukan': 'bubuk',
'membubui': 'bubu',
'bubuhan': 'bubuh',
'membubuh': 'bubuh',
'membubuhkan': 'bubuh',
'membubuhkannya': 'bubuh',
'membubuhi': 'bubuh',
'membubuhan': 'bubuh',
'membubuhinya': 'bubuh',
'pembubuhan': 'bubuh',
'bubukan': 'bubuk',
'membubuk': 'bubuk',
'pembubukan': 'bubuk',
'membubul': 'bubul',
'bubun-bubun': 'bubun',
'bubungan': 'bubung',
'membubung': 'bubung',
'membubungnya': 'bubung',
'membubungkan': 'bubung',
'memperbubungkan': 'bubung',
'membubur': 'bubur',
'membubus': 'bubus',
'bubutan': 'bubut',
'membubut': 'bubut',
'membubuti': 'bubut',
'pembubut': 'bubut',
'pembubutan': 'bubut',
'membudak': 'budak',
'membudaknya': 'budak',
'perbudakan': 'budak',
'perbudakannya': 'budak',
'pembudakan': 'budak',
'membudakkan': 'budak',
'memperbudak': 'budak',
'memperbudaknya': 'budak',
'memperbudakan': 'budak',
'berbudak-budak': 'budak',
'kebudak-budakan': 'budak',
'berbudaya': 'budaya',
'berbudayalah': 'budaya',
'membudaya': 'budaya',
'membudayanya': 'budaya',
'membudayakan': 'budaya',
'membudayakannya': 'budaya',
'kebudayaan': 'budaya',
'kebudayaannya': 'budaya',
'kebudayaanan': 'budaya',
'pembudayaan': 'budaya',
'pembudidaya': 'budi daya',
'pembudidayanya': 'budi daya',
'pembudidayaan': 'budi daya',
'pembudidayaannya': 'budi daya',
'membudidayakan': 'budi daya',
'membudidayakannya': 'budi daya',
'terbudur': 'budur',
'kebugaran': 'bugar',
'kebugarannya': 'bugar',
'kebugaranku': 'bugar',
'pembugaran': 'bugar',
'membugarkan': 'bugar',
'berbugil': 'bugil',
'membugil': 'bugil',
'buhulan': 'buhul',
'membuhul': 'buhul',
'bujangan': 'bujang',
'bujangannya': 'bujang',
'membujang': 'bujang',
'membujangnya': 'bujang',
'kebujangan': 'bujang',
'pembujangan': 'bujang',
'perbujangan': 'bujang',
'kebujanggaan': 'bujangga',
'bujukan': 'bujuk',
'bujukannya': 'bujuk',
'pembujuk': 'bujuk',
'pembujukan': 'bujuk',
'membujuk': 'bujuk',
'membujuknya': 'bujuk',
'membujukkan': 'bujuk',
'membujukku': 'bujuk',
'membujukmu': 'bujuk',
'membujuki': 'bujuk',
'membujur': 'bujur',
'membujurnya': 'bujur',
'terbujur': 'bujur',
'dibujurkan': 'bujur',
'membujurkan': 'bujur',
'mengebuk': 'buk',
'pembuka': 'buka',
'pembukanya': 'buka',
'pembukaan': 'buka',
'terbuka': 'buka',
'terbukanya': 'buka',
'terbukalah': 'buka',
'terbukai': 'buka',
'terbukaan': 'buka',
'terbukamu': 'buka',
'berbuka': 'buka',
'berbukanya': 'buka',
'berbukalah': 'buka',
'berbukaan': 'buka',
'membuka': 'buka',
'membukanya': 'buka',
'membukakan': 'buka',
'membukakannya': 'buka',
'membukaan': 'buka',
'membukai': 'buka',
'pembukaannya': 'buka',
'pembukaanku': 'buka',
'pembukaanmu': 'buka',
'keterbukaan': 'buka',
'keterbukaannya': 'buka',
'keterbukaanlah': 'buka',
'sebukan': 'bukan',
'bukankah': 'bukan',
'bukantah': 'bukan',
'berbukan': 'bukan',
'bukan-bukan': 'bukan',
'membukankan': 'bukan',
'terbuku': 'buku',
'terbukukan': 'buku',
'membuku': 'buku',
'membukukan': 'buku',
'membukukannya': 'buku',
'membukuan': 'buku',
'berbuku': 'buku',
'pembukuan': 'buku',
'pembukuannya': 'buku',
'perbukuan': 'buku',
'membukut': 'bukut',
'pembukut': 'bukut',
'bulakan': 'bulak',
'membulang': 'bulang',
'terbulang': 'bulang',
'berbulang': 'bulang',
'pembulang': 'bulang',
'bulang-bulang': 'bulang',
'bulatan': 'bulat',
'bulatannya': 'bulat',
'membulat': 'bulat',
'membulatnya': 'bulat',
'membulatkan': 'bulat',
'membulatkannya': 'bulat',
'membulati': 'bulat',
'kebulatan': 'bulat',
'kebulatannya': 'bulat',
'pembulatan': 'bulat',
'pembulatannya': 'bulat',
'memperbulat': 'bulat',
'membuldoser': 'buldoser',
'pembuldoseran': 'buldoser',
'pebulu tangkis': 'bulu tangkis',
'perbulutangkisan': 'bulu tangkis',
'pembuluh': 'buluh',
'pembuluhnya': 'buluh',
'pembuluhan': 'buluh',
'berpembuluh': 'buluh',
'buluh-buluh': 'buluh',
'bulukan': 'buluk',
'kebuluran': 'bulur',
'berbumbu': 'bumbu',
'membumbui': 'bumbu',
'membumbuinya': 'bumbu',
'membumbun': 'bumbun',
'membumihanguskan': 'bumi hangus',
'membumihanguskannya': 'bumi hangus',
'membumi': 'bumi',
'membuminya': 'bumi',
'membumilah': 'bumi',
'membumikan': 'bumi',
'membumikannya': 'bumi',
'mengebumikan': 'bumi',
'mengebumikannya': 'bumi',
'membumiratakan': 'bumi rata',
'membuncah': 'buncah',
'membuncahnya': 'buncah',
'membuncahkan': 'buncah',
'terbuncang': 'buncang',
'buncitan': 'buncit',
'membuncit': 'buncit',
'membuncitnya': 'buncit',
'membuncitkan': 'buncit',
'membundak': 'bundak',
'bundaran': 'bundar',
'membundar': 'bundar',
'membundarkan': 'bundar',
'bundelan': 'bundel',
'membundel': 'bundel',
'membundelnya': 'bundel',
'bungaran': 'bungar',
'bungkalan': 'bungkal',
'membungkam': 'bungkam',
'membungkamnya': 'bungkam',
'membungkamkan': 'bungkam',
'membungkamkannya': 'bungkam',
'membungkaman': 'bungkam',
'membungkamku': 'bungkam',
'pembungkam': 'bungkam',
'pembungkamnya': 'bungkam',
'pembungkaman': 'bungkam',
'membungkuk': 'bungkuk',
'membungkuknya': 'bungkuk',
'membungkuklah': 'bungkuk',
'membungkukkan': 'bungkuk',
'membungkukan': 'bungkuk',
'membungkuk-bungkuk': 'bungkuk',
'membungkuk-bungkuklah': 'bungkuk',
'terbungkuk-bungkuk': 'bungkuk',
'membungkus': 'bungkus',
'membungkusnya': 'bungkus',
'membungkuskan': 'bungkus',
'membungkusi': 'bungkus',
'pembungkus': 'bungkus',
'pembungkusnya': 'bungkus',
'pembungkusan': 'bungkus',
'terbuni': 'buni',
'membunikan': 'buni',
'berbuntang': 'buntang',
'terbuntang': 'buntang',
'membuntang': 'buntang',
'membuntangkan': 'buntang',
'buntilan': 'buntil',
'buntingan': 'bunting',
'membunting': 'bunting',
'membuntingkan': 'bunting',
'kebuntingan': 'bunting',
'membuntingi': 'bunting',
'kebuntuan': 'buntu',
'kebuntuannya': 'buntu',
'membuntukan': 'buntu',
'kebuntungan': 'buntung',
'membuntungkan': 'buntung',
'berbuntut': 'buntut',
'pembuntut': 'buntut',
'pembuntutan': 'buntut',
'membuntut': 'buntut',
'membuntuti': 'buntut',
'membuntutinya': 'buntut',
'membuntutiku': 'buntut',
'berbuntut-buntut': 'buntut',
'membunuh': 'bunuh',
'membunuhnya': 'bunuh',
'membunuhkan': 'bunuh',
'membunuhi': 'bunuh',
'membunuhan': 'bunuh',
'membunuhku': 'bunuh',
'membunuhmu': 'bunuh',
'pembunuh': 'bunuh',
'pembunuhnya': 'bunuh',
'pembunuhan': 'bunuh',
'pembunuhku': 'bunuh',
'pembunuhannya': 'bunuh',
'pembunuhani': 'bunuh',
'pembunuhanan': 'bunuh',
'pembunuhanku': 'bunuh',
'bersibunuh': 'bunuh',
'bunuh-membunuh': 'bunuh',
'berbunuh-bunuhan': 'bunuh',
'membura': 'bura',
'memburai': 'burai',
'memburakan': 'bura',
'terburai': 'burai',
'berburai': 'burai',
'memburaikan': 'burai',
'pemburas': 'buras',
'memburas': 'buras',
'memburaskan': 'buras',
'buritan': 'burit',
'buritannya': 'burit',
'memburit': 'burit',
'buronan': 'buron',
'buronannya': 'buron',
'buronanan': 'buron',
'buruhan': 'buruh',
'memburuh': 'buruh',
'memburuhkan': 'buruh',
'perburuhan': 'buruh',
'perburuhannya': 'buruh',
'burukan': 'buruk',
'memburuk': 'buruk',
'memburuknya': 'buruk',
'memburukkan': 'buruk',
'perburuk': 'buruk',
'perburukan': 'buruk',
'berburuk': 'buruk',
'keburukanku': 'buruk',
'berburuk-buruk': 'buruk',
'memburuk-burukkan': 'buruk',
'burung-burungan': 'burung',
'berbusana': 'busana',
'berbusananya': 'busana',
'berbusanalah': 'busana',
'berbusanaku': 'busana',
'membusuk': 'busuk',
'membusuknya': 'busuk',
'membusukkan': 'busuk',
'membusukkannya': 'busuk',
'membusuki': 'busuk',
'membusukan': 'busuk',
'pembusuk': 'busuk',
'pembusukkan': 'busuk',
'pembusukan': 'busuk',
'kebusukan': 'busuk',
'kebusukannya': 'busuk',
'pembusukannya': 'busuk',
'membusung': 'busung',
'membusungkan': 'busung',
'terbusung': 'busung',
'dibusur': 'busur',
'dibusurkan': 'busur',
'membusur': 'busur',
'busur-busur': 'busur',
'membusut': 'busut',
'membuta': 'buta',
'membutanya': 'buta',
'membutakan': 'buta',
'membutakannya': 'buta',
'kebutaan': 'buta',
'kebutaannya': 'buta',
'membutakanku': 'buta',
'kebutuhan': 'butuh',
'kebutuhannya': 'butuh',
'kebutuhanlah': 'butuh',
'kebutuhanan': 'butuh',
'kebutuhanku': 'butuh',
'kebutuhanmu': 'butuh',
'membutuhi': 'butuh',
'membutuhkan': 'butuh',
'membutuhkannya': 'butuh',
'membutuhkanlah': 'butuh',
'membutuhkanku': 'butuh',
'membutuhkanmu': 'butuh',
'membutuhkan-mu': 'butuh',
'butulan': 'butul',
'membuyarkan': 'buyar',
'membuyarkannya': 'buyar',
'membuyur': 'buyur',
'kecabaian': 'cabai',
'kecabaran': 'cabar',
'mencabarkan': 'cabar',
'mencabau': 'cabau',
'cabikan': 'cabik',
'tercabik': 'cabik',
'tercabiknya': 'cabik',
'mencabik': 'cabik',
'mencabiknya': 'cabik',
'pencabikan': 'cabik',
'mencabikkan': 'cabik',
'cabik-cabik': 'cabik',
'mencabik-cabik': 'cabik',
'cabik-mencabik': 'cabik',
'mencabik-cabikkan': 'cabik',
'bercabiran': 'cabir',
'cobar-cabir': 'cabir',
'kecabuhan': 'cabuh',
'mencabul': 'cabul',
'mencabuli': 'cabul',
'bercabul': 'cabul',
'kecabulan': 'cabul',
'kecabulannya': 'cabul',
'mencabulinya': 'cabul',
'pencabulan': 'cabul',
'pencabulannya': 'cabul',
'percabulan': 'cabul',
'kecaburan': 'cabur',
'cabutan': 'cabut',
'cabutannya': 'cabut',
'tercabut': 'cabut',
'tercabutnya': 'cabut',
'mencabut': 'cabut',
'mencabutnya': 'cabut',
'mencabutlah': 'cabut',
'mencabutkan': 'cabut',
'mencabutkannya': 'cabut',
'mencabuti': 'cabut',
'mencabutan': 'cabut',
'bercabut': 'cabut',
'pencabut': 'cabut',
'pencabutnya': 'cabut',
'pencabutan': 'cabut',
'pencabutannya': 'cabut',
'pencacah jiwa': 'cacah jiwa',
'mencacah jiwa': 'cacah jiwa',
'bercacah jiwa': 'cacah jiwa',
'pencacahjiwaan': 'cacah jiwa',
'pencacak': 'cacak',
'mencacak': 'cacak',
'tercacak': 'cacak',
'mencacakkan': 'cacak',
'mencacap': 'cacap',
'mencacapi': 'cacap',
'bercacar': 'cacar',
'pencacar': 'cacar',
'mencacar': 'cacar',
'pencacaran': 'cacar',
'cacatan': 'cacat',
'cacatannya': 'cacat',
'bercacat': 'cacat',
'pencacat': 'cacat',
'pencacatan': 'cacat',
'tercacat': 'cacat',
'tercacatkan': 'cacat',
'mencacat': 'cacat',
'mencacatkan': 'cacat',
'mencacatkannya': 'cacat',
'mencacati': 'cacat',
'kecacatan': 'cacat',
'kecacatannya': 'cacat',
'pencacatannya': 'cacat',
'mencacau': 'cacau',
'pencacau': 'cacau',
'cacian': 'caci',
'caciannya': 'caci',
'cacianlah': 'caci',
'pencaci': 'caci',
'pencacinya': 'caci',
'mencaci': 'caci',
'mencacinya': 'caci',
'mencaciku': 'caci',
'bercaci-cacian': 'caci',
'mencaci maki': 'caci maki',
'cacingan': 'cacing',
'mencadai': 'cadai',
'cadangan': 'cadang',
'cadangannya': 'cadang',
'cadanganlah': 'cadang',
'cadangankan': 'cadang',
'cadanganku': 'cadang',
'pencadang': 'cadang',
'pencadangan': 'cadang',
'bercadang': 'cadang',
'bercadangan': 'cadang',
'pencadangannya': 'cadang',
'pencadanganan': 'cadang',
'mencadangkan': 'cadang',
'mencadangkannya': 'cadang',
'mencadangkanku': 'cadang',
'bercadar': 'cadar',
'bercadik': 'cadik',
'mencaduk': 'caduk',
'bercadung': 'cadung',
'mencadung': 'cadung',
'tercagak': 'cagak',
'mencagak': 'cagak',
'bercagak': 'cagak',
'cagaran': 'cagar',
'pencagaran': 'cagar',
'mencagarkan': 'cagar',
'mencagil': 'cagil',
'mencagun': 'cagun',
'mencagut': 'cagut',
'pencahar': 'cahar',
'pencaharnya': 'cahar',
'mencahar': 'cahar',
'mencahari': 'cahar',
'pencaharian': 'cahari',
'pencahariannya': 'cahari',
'pencaharianku': 'cahari',
'bercahaya': 'cahaya',
'bercahayanya': 'cahaya',
'bercahayakan': 'cahaya',
'mencahayai': 'cahaya',
'pencahayaan': 'cahaya',
'pencahayaannya': 'cahaya',
'mencahayakan': 'cahaya',
'caing-caing': 'caing',
'mencaing-caing': 'caing',
'cairan': 'cair',
'cairannya': 'cair',
'cairanlah': 'cair',
'mencair': 'cair',
'mencairnya': 'cair',
'mencairlah': 'cair',
'mencairkan': 'cair',
'mencairkannya': 'cair',
'mencairan': 'cair',
'cecairan': 'cair',
'pencairan': 'cair',
'pencairannya': 'cair',
'mencakah': 'cakah',
'pecakak': 'cakak',
'bercakak': 'cakak',
'mencakar': 'cakar',
'mencakarnya': 'cakar',
'mencakari': 'cakar',
'mencakarku': 'cakar',
'pencakar': 'cakar',
'pencakarnya': 'cakar',
'pencakaran': 'cakar',
'bersicakar': 'cakar',
'cakar-mencakar': 'cakar',
'bercakar-cakaran': 'cakar',
'bercakrawala': 'cakrawala',
'cakupan': 'cakup',
'cakupannya': 'cakup',
'cakupanan': 'cakup',
'pencakup': 'cakup',
'pencakupan': 'cakup',
'tercakup': 'cakup',
'tercakupnya': 'cakup',
'tercakupi': 'cakup',
'mencakup': 'cakup',
'mencakupnya': 'cakup',
'mencakupkan': 'cakup',
'mencakupi': 'cakup',
'mencakupan': 'cakup',
'cakup-mencakup': 'cakup',
'mencakup-cakup': 'cakup',
'mencakus': 'cakus',
'mencalak': 'calak',
'calak-calak': 'calak',
'mencalang': 'calang',
'pencalang': 'calang',
'mencalit': 'calit',
'bercalit': 'calit',
'mencalitkan': 'calit',
'percaloan': 'calo',
'percaloannya': 'calo',
'pencalonan': 'calon',
'pencalonannya': 'calon',
'pencalonanan': 'calon',
'pencalonanku': 'calon',
'mencalonkan': 'calon',
'mencalonkannya': 'calon',
'mencalonkanlah': 'calon',
'mencamkan': 'cam',
'kecamatan': 'camat',
'kecamatannya': 'camat',
'kecamatanan': 'camat',
'bercambang': 'cambang',
'mencambuk': 'cambuk',
'mencambuknya': 'cambuk',
'mencambukkan': 'cambuk',
'mencambuki': 'cambuk',
'mencambukku': 'cambuk',
'mencambukmu': 'cambuk',
'mencambukinya': 'cambuk',
'pencambukan': 'cambuk',
'camilan': 'camil',
'camilannya': 'camil',
'camilanmu': 'camil',
'mencampak': 'campak',
'mencampakkan': 'campak',
'mencampakkannya': 'campak',
'mencampakan': 'campak',
'tercampak': 'campak',
'tercampakkan': 'campak',
'tercampakan': 'campak',
'mencampakkanku': 'campak',
'mencampakkanmu': 'campak',
'mencampang': 'campang',
'secampin': 'campin',
'campang-camping': 'camping',
'bercamping-camping': 'camping',
'mencampung': 'campung',
'tercampung': 'campung',
'kecampuradukan': 'campur aduk',
'bercampur aduk': 'campur aduk',
'pencampuradukan': 'campur aduk',
'mencampuradukkan': 'campur aduk',
'mencampuradukkannya': 'campur aduk',
'bercampur baur': 'campur baur',
'pencampurbauran': 'campur baur',
'mencampurbaurkan': 'campur baur',
'campuran': 'campur',
'campurannya': 'campur',
'bercampur': 'campur',
'bercampurnya': 'campur',
'bercampuran': 'campur',
'tercampur': 'campur',
'tercampurnya': 'campur',
'tercampurlah': 'campur',
'tercampurkan': 'campur',
'tercampuri': 'campur',
'mencampur': 'campur',
'mencampurnya': 'campur',
'mencampurkan': 'campur',
'mencampurkannya': 'campur',
'mencampuri': 'campur',
'mencampurinya': 'campur',
'percampuran': 'campur',
'percampurannya': 'campur',
'pencampuran': 'campur',
'pencampurannya': 'campur',
'bercamuk': 'camuk',
'mencamuk': 'camuk',
'mencamurkan': 'camur',
'canaian': 'canai',
'mencanai': 'canai',
'pencanai': 'canai',
'pencanaian': 'canai',
'mencanak': 'canak',
'pencanang': 'canang',
'pencanangkan': 'canang',
'pencanangan': 'canang',
'tercanang': 'canang',
'pencanangannya': 'canang',
'pencananganan': 'canang',
'mencanangkan': 'canang',
'mencanangkannya': 'canang',
'mencancang': 'cancang',
'tercancang': 'cancang',
'bercancut': 'cancut',
'mencancutkan': 'cancut',
'bercanda': 'canda',
'bercandanya': 'canda',
'bercandalah': 'canda',
'bercandai': 'canda',
'bercandaan': 'canda',
'percandian': 'candi',
'pencandraan': 'candra',
'mencandrakan': 'candra',
'pecandu': 'candu',
'pecandunya': 'candu',
'mencandu': 'candu',
'pencandu': 'candu',
'pencandunya': 'candu',
'mencandui': 'candu',
'kecanduan': 'candu',
'kecanduannya': 'candu',
'kecanduanku': 'candu',
'percanduan': 'candu',
'mencandukan': 'candu',
'tercangah': 'cangah',
'mencangah': 'cangah',
'mencangak': 'cangak',
'mencangakan': 'cangak',
'tercangak-cangak': 'cangak',
'mencangam': 'cangam',
'bercangap': 'cangap',
'mencangar': 'cangar',
'mencangcang': 'cangcang',
'kecanggihan': 'canggih',
'kecanggihannya': 'canggih',
'tercanggung': 'canggung',
'kecanggungan': 'canggung',
'kecanggungannya': 'canggung',
'mencanggungkan': 'canggung',
'mencangkel': 'cangkel',
'tercangkel': 'cangkel',
'mencangkelkan': 'cangkel',
'cangkingan': 'cangking',
'mencangking': 'cangking',
'mencangklong': 'cangklong',
'cangkolan': 'cangkol',
'cangkulan': 'cangkul',
'cangkulannya': 'cangkul',
'mencangkul': 'cangkul',
'mencangkuli': 'cangkul',
'mencangkum': 'cangkum',
'bercangkung': 'cangkung',
'mencangkung': 'cangkung',
'mencangkup': 'cangkup',
'mencangkupi': 'cangkup',
'mencanguk': 'canguk',
'kecantasan': 'cantas',
'cantelan': 'cantel',
'cantelannya': 'cantel',
'mencantelkan': 'cantel',
'cantengan': 'canteng',
'tercantik': 'cantik',
'tercantiknya': 'cantik',
'tercantiklah': 'cantik',
'tercantikku': 'cantik',
'kecantikan': 'cantik',
'kecantikannya': 'cantik',
'kecantikanku': 'cantik',
'kecantikanmu': 'cantik',
'pemercantik': 'cantik',
'mencantikkan': 'cantik',
'mempercantik': 'cantik',
'mempercantiknya': 'cantik',
'mempercantikan': 'cantik',
'bercantik-cantik': 'cantik',
'cantolan': 'cantol',
'cantolannya': 'cantol',
'kecantol': 'cantol',
'tercantol': 'cantol',
'mencantolkan': 'cantol',
'bercap': 'cap',
'bercapkan': 'cap',
'mengecap': 'kecap',
'mengecapnya': 'kecap',
'mengecapkan': 'kecap',
'mengecapi': 'kecap',
'pengecapan': 'kecap',
'pengecapannya': 'kecap',
'capaian': 'capai',
'capaiannya': 'capai',
'tercapai': 'capai',
'tercapainya': 'capai',
'tercapailah': 'capai',
'tercapaikan': 'capai',
'tercapaian': 'capai',
'pencapai': 'capai',
'pencapainya': 'capai',
'pencapaikan': 'capai',
'pencapaian': 'capai',
'mencapai': 'capai',
'mencapainya': 'capai',
'mencapaikan': 'capai',
'mencapaii': 'capai',
'mencapaian': 'capai',
'kecapaian': 'capai',
'pencapaiannya': 'capai',
'pencapaianku': 'capai',
'pencapaianmu': 'capai',
'sepencapai': 'capai',
'mencapak': 'capak',
'mencapakkan': 'capak',
'mencapaki': 'capak',
'tercapak': 'capak',
'mempercapak': 'capak',
'mencapak-capak': 'capak',
'pencaplok': 'caplok',
'pencaplokan': 'caplok',
'tercaplok': 'caplok',
'tercaploknya': 'caplok',
'mencaplok': 'caplok',
'mencaploknya': 'caplok',
'pencaplokannya': 'caplok',
'secara': 'cara',
'secaranya': 'cara',
'secarai': 'cara',
'mencarah': 'carah',
'bercarah': 'carah',
'mencarahkan': 'carah',
'mencarak': 'carak',
'pencarak': 'carak',
'bercaran': 'caran',
'mencarang': 'carang',
'bercarang': 'carang',
'carian': 'cari',
'cariannya': 'cari',
'mencari': 'cari',
'mencarinya': 'cari',
'mencarikan': 'cari',
'mencarikannya': 'cari',
'mencarii': 'cari',
'mencarian': 'cari',
'mencariku': 'cari',
'mencarimu': 'cari',
'tercari': 'cari',
'pencari': 'cari',
'pencarinya': 'cari',
'pencarian': 'cari',
'pencari-mu': 'cari',
'bercari': 'cari',
'pencariannya': 'cari',
'pencarianlah': 'cari',
'pencarianmu': 'cari',
'mencarikanku': 'cari',
'cari-carian': 'cari',
'mencari-cari': 'cari',
'mencari-carinya': 'cari',
'mencari-carilah': 'cari',
'bercari-cari': 'cari',
'bercari-carian': 'cari',
'carikan': 'carik',
'carikanlah': 'carik',
'secarik': 'carik',
'mencarik': 'carik',
'mencarik-carik': 'carik',
'bercarik-carik': 'carik',
'mencarik-carikkan': 'carik',
'mencaring': 'caring',
'carteran': 'carter',
'pencarter': 'carter',
'pencarteran': 'carter',
'mencarter': 'carter',
'mencaruk': 'caruk',
'bercarut': 'carut',
'pencarut': 'carut',
'carut-marut': 'carut',
'carut-marutnya': 'carut',
'mempercaruti': 'carut',
'mencarut-carut': 'carut',
'bercarut-carut': 'carut',
'mengecas': 'cas',
'mengecasnya': 'cas',
'mengecaskan': 'cas',
'catatan': 'catat',
'catatannya': 'catat',
'catatanku': 'catat',
'catatanmu': 'catat',
'tercatat': 'catat',
'tercatatnya': 'catat',
'tercatatlah': 'catat',
'tercatatkan': 'catat',
'tercatatan': 'catat',
'pencatat': 'catat',
'pencatatnya': 'catat',
'pencatatkan': 'catat',
'pencatatan': 'catat',
'mencatat': 'catat',
'mencatatnya': 'catat',
'mencatatkan': 'catat',
'mencatatkannya': 'catat',
'mencatati': 'catat',
'mencatatan': 'catat',
'mencatatmu': 'catat',
'pencatatannya': 'catat',
'mencatek': 'catek',
'catuan': 'catu',
'mencatu': 'catu',
'pencatu': 'catu',
'pencatuan': 'catu',
'mencatuk': 'catuk',
'tercatuk': 'catuk',
'pecatur': 'catur',
'pecaturnya': 'catur',
'pecaturan': 'catur',
'caturan': 'catur',
'caturani': 'catur',
'bercatur': 'catur',
'percaturan': 'catur',
'percaturannya': 'catur',
'catutan': 'catut',
'bercatut': 'catut',
'mencatut': 'catut',
'mencatutnya': 'catut',
'mencatutkan': 'catut',
'pencatut': 'catut',
'pencatutnya': 'catut',
'pencatutan': 'catut',
'percatutan': 'catut',
'bercawak': 'cawak',
'bercawat': 'cawat',
'mencawatkan': 'cawat',
'cawi-cawi': 'cawi',
'cebakan': 'cebak',
'mencebak': 'cebak',
'pencebak': 'cebak',
'bercebak': 'cebak',
'percebakan': 'cebak',
'pencebakan': 'cebak',
'mencebik': 'cebik',
'mencebikkan': 'cebik',
'mencebil': 'cebil',
'mencebilkan': 'cebil',
'secebir': 'cebir',
'mencebir': 'cebir',
'secebis': 'cebis',
'bercebok': 'cebok',
'menceboki': 'cebok',
'mencebur': 'cebur',
'menceburkan': 'cebur',
'menceburkannya': 'cebur',
'tercebur': 'cebur',
'terceburnya': 'cebur',
'cebar-cebur': 'cebur',
'bercebar-cebur': 'cebur',
'sececah': 'cecah',
'tercecah': 'cecah',
'bercecah': 'cecah',
'mencecah': 'cecah',
'mencecahkan': 'cecah',
'mencecak': 'cecak',
'pencecak': 'cecak',
'mencecap': 'cecap',
'mencecapnya': 'cecap',
'mencecar': 'cecar',
'mencecarnya': 'cecar',
'mencecari': 'cecar',
'mencecarmu': 'cecar',
'tercedera': 'cedera',
'tercederai': 'cedera',
'mencedera': 'cedera',
'mencederakan': 'cedera',
'mencederai': 'cedera',
'bercedera': 'cedera',
'kecederaan': 'cedera',
'kecederaannya': 'cedera',
'mencederainya': 'cedera',
'mencederaiku': 'cedera',
'percederaan': 'cedera',
'pencederaan': 'cedera',
'mencedok': 'cedok',
'pencedok': 'cedok',
'tercegah': 'cegah',
'tercegahnya': 'cegah',
'mencegah': 'cegah',
'mencegahnya': 'cegah',
'mencegahlah': 'cegah',
'mencegahkan': 'cegah',
'mencegahan': 'cegah',
'mencegahku': 'cegah',
'mencegahmu': 'cegah',
'pencegah': 'cegah',
'pencegahnya': 'cegah',
'pencegahan': 'cegah',
'pencegahannya': 'cegah',
'pencegahanlah': 'cegah',
'pencegahanan': 'cegah',
'mencegat': 'cegat',
'mencegatnya': 'cegat',
'mencegatku': 'cegat',
'mencegatmu': 'cegat',
'pencegatan': 'cegat',
'pencegatannya': 'cegat',
'cegukan': 'ceguk',
'cegukannya': 'ceguk',
'pengecek': 'kecek',
'pengeceknya': 'kecek',
'pengecekkan': 'kecek',
'pengecekan': 'kecek',
'mengecek': 'kecek',
'mengeceknya': 'kecek',
'mengecekkan': 'kecek',
'mengeceki': 'kecek',
'mengecekan': 'kecek',
'pengecekannya': 'cek',
'bercekah': 'cekah',
'mencekah': 'cekah',
'bercekak': 'cekak',
'mencekak': 'cekak',
'mencekakkan': 'cekak',
'mempercekakkan': 'cekak',
'bercekakakan': 'cekakak',
'cekakak cekikik': 'cekakak',
'bercekakak cekikik': 'cekakak',
'cekalan': 'cekal',
'mencekal': 'cekal',
'mencekalnya': 'cekal',
'pencekalan': 'cekal',
'pencekalannya': 'cekal',
'mencekalkan': 'cekal',
'cekaman': 'cekam',
'tercekam': 'cekam',
'mencekam': 'cekam',
'mencekamnya': 'cekam',
'mencekamkan': 'cekam',
'mencekamku': 'cekam',
'cekatan': 'cekat',
'cekatannya': 'cekat',
'kecekatan': 'cekat',
'kecekatannya': 'cekat',
'mencekau': 'cekau',
'bercekcok': 'cekcok',
'mencekcoki': 'cekcok',
'percekcokan': 'cekcok',
'percekcokannya': 'cekcok',
'mempercekcokkan': 'cekcok',
'menceker': 'ceker',
'mencekih': 'cekih',
'tercekih': 'cekih',
'cekikan': 'cekik',
'cekikannya': 'cekik',
'pencekik': 'cekik',
'pencekikan': 'cekik',
'tercekik': 'cekik',
'tercekiklah': 'cekik',
'bercekik': 'cekik',
'mencekik': 'cekik',
'mencekiknya': 'cekik',
'mencekikku': 'cekik',
'mencekikmu': 'cekik',
'mempercekikkan': 'cekik',
'cekikikan': 'cekikik',
'bercekikikan': 'cekikik',
'bercekit': 'cekit',
'mencekit': 'cekit',
'tercekluk': 'cekluk',
'cekokan': 'cekok',
'mencekok': 'cekok',
'mencekokkan': 'cekok',
'mencekoki': 'cekok',
'mencekokinya': 'cekok',
'menceku': 'ceku',
'mencekukan': 'ceku',
'mencekuh': 'cekuh',
'kecekungan': 'cekung',
'mencekup': 'cekup',
'mencekut': 'cekut',
'celaan': 'cela',
'celaannya': 'cela',
'bercela': 'cela',
'tercela': 'cela',
'tercelanya': 'cela',
'tercelalah': 'cela',
'pencela': 'cela',
'pencelanya': 'cela',
'pencelaan': 'cela',
'mencela': 'cela',
'mencelanya': 'cela',
'mencelakan': 'celak',
'kecelaan': 'cela',
'bercelah': 'celah',
'mencelak': 'celak',
'bercelak': 'celak',
'mencelaki': 'celak',
'mencelakai': 'celaka',
'mencelakainya': 'celaka',
'mencelakaimu': 'celaka',
'kecelakaan': 'celaka',
'kecelakaannya': 'celaka',
'kecelakaankan': 'celaka',
'mencelakakan': 'celaka',
'mencelakakannya': 'celaka',
'tercelampak': 'celampak',
'mencelampakkan': 'celampak',
'bercelana': 'celana',
'mencelang': 'celang',
'mencelangakkan': 'celangak',
'tercelapak': 'celapak',
'mencelapaki': 'celapak',
'mencelat': 'celat',
'mencelatnya': 'celat',
'mencelatlah': 'celat',
'bercelatuk': 'celatuk',
'celengan': 'celeng',
'celengannya': 'celeng',
'celenganku': 'celeng',
'celenganmu': 'celeng',
'mencelengi': 'celeng',
'tercelentang': 'celentang',
'mencelep': 'celep',
'menceletuk': 'celetuk',
'menceletukkan': 'celetuk',
'mencelikkan': 'celik',
'celingukan': 'celinguk',
'celingak-celinguk': 'celinguk',
'mencelis': 'celis',
'tercelomok': 'celomok',
'menceluk': 'celuk',
'mencelung': 'celung',
'mencelungkan': 'celung',
'celung-celung': 'celung',
'mencelup': 'celup',
'mencelupnya': 'celup',
'mencelupkan': 'celup',
'mencelupkannya': 'celup',
'pencelup': 'celup',
'pencelupan': 'celup',
'celuran': 'celur',
'bercelur': 'celur',
'mencelur': 'celur',
'penceluran': 'celur',
'mencelus': 'celus',
'tercelus': 'celus',
'celas-celus': 'celus',
'mencema': 'cema',
'mencemakan': 'cema',
'tercema': 'cema',
'cemaran': 'cemar',
'cemarannya': 'cemar',
'pencemar': 'cemar',
'pencemarnya': 'cemar',
'pencemari': 'cemar',
'pencemaran': 'cemar',
'tercemar': 'cemar',
'tercemarnya': 'cemar',
'tercemarkan': 'cemar',
'tercemari': 'cemar',
'bercemar': 'cemar',
'kecemaran': 'cemar',
'mencemari': 'cemar',
'mencemarinya': 'cemar',
'pencemarannya': 'cemar',
'pencemaranan': 'cemar',
'mencemarkan': 'cemar',
'mencemarkannya': 'cemar',
'pencemas': 'cemas',
'tercemas': 'cemas',
'bercemas': 'cemas',
'kecemasan': 'cemas',
'kecemasannya': 'cemas',
'kecemasanku': 'cemas',
'kecemasanmu': 'cemas',
'mencemaskan': 'cemas',
'mencemaskannya': 'cemas',
'mencemaskanku': 'cemas',
'cemas-cemas': 'cemas',
'mencemat': 'cemat',
'mencemati': 'cemat',
'cemburuan': 'cemburu',
'cemburuannya': 'cemburu',
'bercemburu': 'cemburu',
'kecemburuan': 'cemburu',
'kecemburuannya': 'cemburu',
'kecemburuanku': 'cemburu',
'mencemburui': 'cemburu',
'mencemburuinya': 'cemburu',
'bercemburuan': 'cemburu',
'mencemburukan': 'cemburu',
'pencemeeh': 'cemeeh',
'mencemeehkan': 'cemeeh',
'kecemerlangan': 'cemerlang',
'kecemerlangannya': 'cemerlang',
'kecemerlanganmu': 'cemerlang',
'mencemerlangkan': 'cemerlang',
'mencemeti': 'cemeti',
'bercemetuk': 'cemetuk',
'cemoohan': 'cemooh',
'cemoohannya': 'cemooh',
'mencemooh': 'cemooh',
'mencemoohnya': 'cemooh',
'mencemoohkan': 'cemooh',
'mencemoohkannya': 'cemooh',
'mencemoohan': 'cemooh',
'mencemoohku': 'cemooh',
'bercempera': 'cempera',
'tercemplung': 'cemplung',
'mencemplung': 'cemplung',
'mencemplungkan': 'cemplung',
'mencemplungkannya': 'cemplung',
'pencemplungan': 'cemplung',
'mencempung': 'cempung',
'mencempungi': 'cempung',
'mencempungkan': 'cempung',
'mencemuk': 'cemuk',
'kecenaan': 'cena',
'cencangan': 'cencang',
'bercencang': 'cencang',
'mencencang': 'cencang',
'cencang latih': 'cencang',
'kecendekiaan': 'cendekia',
'pencendekiaan': 'cendekia',
'mencendekiakan': 'cendekia',
'kecendekiawanan': 'cendekiawan',
'kecendekiawanannya': 'cendekiawan',
'kecenderungan': 'cenderung',
'kecenderungannya': 'cenderung',
'kecenderunganlah': 'cenderung',
'kecenderunganku': 'cenderung',
'berkecenderungan': 'cenderung',
'bercenduai': 'cenduai',
'mencengam': 'cengam',
'tercengang': 'cengang',
'tercengangnya': 'cengang',
'bersicengang': 'cengang',
'bercengangan': 'cengang',
'mencengangkan': 'cengang',
'mencengangkannya': 'cengang',
'tercengang-cengang': 'cengang',
'mencengap': 'cengap',
'mencengis-cengis': 'cengis-cengis',
'cengkaman': 'cengkam',
'mencengkam': 'cengkam',
'mencengkamkan': 'cengkam',
'mencengkelong': 'cengkelong',
'cengkeraman': 'cengkeram',
'cengkeramannya': 'cengkeram',
'mencengkeram': 'cengkeram',
'mencengkeramnya': 'cengkeram',
'mencengkeramkan': 'cengkeram',
'bercengkih': 'cengkih',
'percengkihan': 'cengkih',
'bercengkung': 'cengkung',
'tercengung': 'cengung',
'mencengut': 'cengut',
'tercengut': 'cengut',
'mencentang': 'centang',
'centang-perenang': 'centang',
'kecentang-perenangan': 'centang',
'kecentilan': 'centil',
'mencentong': 'centong',
'tercenung': 'cenung',
'mencepak-cepak': 'cepak',
'cepalan': 'cepal',
'secepat': 'cepat',
'secepatnya': 'cepat',
'secepatlah': 'cepat',
'secepatkan': 'cepat',
'secepatnyalah': 'cepat',
'mencepat': 'cepat',
'kecepatan': 'cepat',
'kecepatannya': 'cepat',
'kecepatanlah': 'cepat',
'kecepatanan': 'cepat',
'kecepatanku': 'cepat',
'bersecepat': 'cepat',
'percepatan': 'cepat',
'percepatannya': 'cepat',
'percepatanlah': 'cepat',
'bersicepat': 'cepat',
'pencepatan': 'cepat',
'pemercepat': 'cepat',
'pemercepatan': 'cepat',
'mencepatkan': 'cepat',
'mempercepat': 'cepat',
'mempercepatnya': 'cepat',
'mempercepatlah': 'cepat',
'mempercepatan': 'cepat',
'cepat-cepat': 'cepat',
'cepat-cepatlah': 'cepat',
'cepat-cepatkan': 'cepat',
'cepat-cepatan': 'cepat',
'berkecepatan': 'cepat',
'berkecepatanan': 'cepat',
'bercepat-cepat': 'cepat',
'keceplosan': 'ceplos',
'keceplosannya': 'ceplos',
'menceploskan': 'ceplos',
'menceploskannya': 'ceplos',
'mencepol': 'cepol',
'mencepuk': 'cepuk',
'mencepuk-cepuk': 'cepuk',
'mencerabih': 'cerabih',
'tercerabut': 'cerabut',
'tercerabutnya': 'cerabut',
'menceracam': 'ceracam',
'penceracau': 'ceracau',
'menceracau': 'ceracau',
'kecerahan': 'cerah',
'kecerahannya': 'cerah',
'pencerahan': 'cerah',
'pencerahannya': 'cerah',
'pencerahanlah': 'cerah',
'pencerahanan': 'cerah',
'mencerahkan': 'cerah',
'mencerahkannya': 'cerah',
'bercerai-berai': 'cerai-berai',
'mencerai-beraikan': 'cerai-berai',
'bercerak': 'cerak',
'bercerancangan': 'cerancang',
'cerapan': 'cerap',
'mencerap': 'cerap',
'tercerap': 'cerap',
'pencerapan': 'cerap',
'ceratan': 'cerat',
'mencerat': 'cerat',
'mencerati': 'cerat',
'mencerataikan': 'ceratai',
'berceratuk': 'ceratuk',
'menceratuk': 'ceratuk',
'berceratukan': 'ceratuk',
'cercaan': 'cerca',
'cercaannya': 'cerca',
'mencerca': 'cerca',
'mencercanya': 'cerca',
'mencercaku': 'cerca',
'mencercai': 'cerca',
'cercahan': 'cercah',
'secercah': 'cercah',
'mencercah': 'cercah',
'mencercap': 'cercap',
'kecerdasan': 'cerdas',
'kecerdasannya': 'cerdas',
'kecerdasanlah': 'cerdas',
'kecerdasanan': 'cerdas',
'kecerdasanmu': 'cerdas',
'pencerdasan': 'cerdas',
'mencerdaskan': 'cerdas',
'mencerdaskannya': 'cerdas',
'kecerdikan': 'cerdik',
'kecerdikannya': 'cerdik',
'kecerewetan': 'cerewet',
'kecerewetannya': 'cerewet',
'mencereweti': 'cerewet',
'mencerewetinya': 'cerewet',
'kecergasan': 'cergas',
'keceriaan': 'ceria',
'keceriaannya': 'ceria',
'keceriaanmu': 'ceria',
'penceriaan': 'ceria',
'menceriakan': 'ceria',
'bercericau': 'cericau',
'mencerkau': 'cerkau',
'mencerlang': 'cerlang',
'kecerlangan': 'cerlang',
'kecerlangannya': 'cerlang',
'mencerling': 'cerling',
'kecermatan': 'cermat',
'kecermatannya': 'cermat',
'mencermati': 'cermat',
'mencermatinya': 'cermat',
'mencermatkan': 'cermat',
'cerminan': 'cermin',
'cerminannya': 'cermin',
'cerminanan': 'cermin',
'cerminanku': 'cermin',
'becermin': 'cermin',
'tercermin': 'cermin',
'tercerminnya': 'cermin',
'tercerminkan': 'cermin',
'bercermin': 'cermin',
'bercerminlah': 'cermin',
'mencermini': 'cermin',
'mencerminkan': 'cermin',
'mencerminkannya': 'cermin',
'mempercermin': 'cermin',
'tecerna': 'cerna',
'mencerna': 'cerna',
'mencernanya': 'cerna',
'mencernakan': 'cerna',
'mencernaan': 'cerna',
'pencernaan': 'cerna',
'pencernaannya': 'cerna',
'pencernaanku': 'cerna',
'menceroboh': 'ceroboh',
'mencerobohi': 'ceroboh',
'kecerobohan': 'ceroboh',
'kecerobohannya': 'ceroboh',
'kecerobohanlah': 'ceroboh',
'mencerocos': 'cerocos',
'berceroteh': 'ceroteh',
'mencerowok': 'cerowok',
'mencerucup': 'cerucup',
'menceruh': 'ceruh',
'menceruk': 'ceruk',
'ceruk-meruk': 'ceruk',
'ceruk-menceruk': 'ceruk',
'mencerup': 'cerup',
'mencerut': 'cerut',
'mencetai-cetai': 'cetai',
'bercetai-cetai': 'cetai',
'cetakan': 'cetak',
'cetakannya': 'cetak',
'bercetak': 'cetak',
'bercetakan': 'cetak',
'mencetak': 'cetak',
'mencetaknya': 'cetak',
'mencetakkan': 'cetak',
'mencetakkannya': 'cetak',
'mencetaki': 'cetak',
'mencetakan': 'cetak',
'pencetak': 'cetak',
'pencetaknya': 'cetak',
'pencetakkan': 'cetak',
'pencetakkannya': 'cetak',
'pencetakan': 'cetak',
'pencetakannya': 'cetak',
'percetakan': 'cetak',
'percetakannya': 'cetak',
'percetakanmu': 'cetak',
'cetak-mencetak': 'cetak',
'cetar-ceter': 'cetar',
'menceteng': 'ceteng',
'menceti': 'ceti',
'mencetikan': 'ceti',
'cetusan': 'cetus',
'cetusannya': 'cetus',
'mencetus': 'cetus',
'mencetusnya': 'cetus',
'mencetuskan': 'cetus',
'mencetuskannya': 'cetus',
'tercetus': 'cetus',
'tercetusnya': 'cetus',
'tercetuslah': 'cetus',
'tercetuskan': 'cetus',
'pencetus': 'cetus',
'pencetusnya': 'cetus',
'pencetusan': 'cetus',
'menciak': 'ciak',
'menciak-ciak': 'ciak',
'seciap': 'ciap',
'menciap-ciap': 'ciap',
'berciap-ciap': 'ciap',
'menciar-ciar': 'ciar',
'mencibir': 'cibir',
'mencibirnya': 'cibir',
'mencibirkan': 'cibir',
'mencibirku': 'cibir',
'mencibit': 'cibit',
'mencicik': 'cicik',
'cicilan': 'cicil',
'cicilannya': 'cicil',
'cicilanlah': 'cicil',
'cicilanmu': 'cicil',
'mencicil': 'cicil',
'mencicilnya': 'cicil',
'pencicilan': 'cicil',
'pencicilannya': 'cicil',
'mencicip': 'cicip',
'mencicipnya': 'cicip',
'mencicipi': 'cicip',
'mencicipinya': 'cicip',
'mencicit': 'cicit',
'mencicitkan': 'cicit',
'cidukan': 'ciduk',
'menciduk': 'ciduk',
'menciduknya': 'ciduk',
'menciduki': 'ciduk',
'mencidukku': 'ciduk',
'terciduk': 'ciduk',
'bercikun-cikun': 'cikun',
'cikutan': 'cikut',
'tercilap-cilap': 'cilap',
'mencilok': 'cilok',
'pencilok': 'cilok',
'mencina': 'cina',
'mencinai': 'cina',
'mencincang': 'cincang',
'mencincangnya': 'cincang',
'cingak-cinguk': 'cingak',
'tercingangah': 'cingangah',
'menciplak': 'ciplak',
'cipratan': 'ciprat',
'cipratannya': 'ciprat',
'menciprat': 'ciprat',
'mencipratkan': 'ciprat',
'menciprati': 'ciprat',
'terciprat': 'ciprat',
'kecipratan': 'ciprat',
'kecipratannya': 'ciprat',
'ciptaan': 'cipta',
'ciptaannya': 'cipta',
'ciptaanku': 'cipta',
'ciptaanmu': 'cipta',
'ciptaan-ku': 'cipta',
'ciptaan-mu': 'cipta',
'tercipta': 'cipta',
'terciptanya': 'cipta',
'terciptalah': 'cipta',
'terciptakan': 'cipta',
'mencipta': 'cipta',
'menciptanya': 'cipta',
'menciptakan': 'cipta',
'menciptakannya': 'cipta',
'menciptai': 'cipta',
'menciptaan': 'cipta',
'pencipta': 'cipta',
'penciptanya': 'cipta',
'penciptakan': 'cipta',
'penciptaan': 'cipta',
'penciptaku': 'cipta',
'penciptamu': 'cipta',
'penciptaannya': 'cipta',
'menciptakanku': 'cipta',
'berciri': 'ciri',
'bercirikan': 'ciri',
'pencirian': 'ciri',
'mencirikan': 'ciri',
'mencirikannya': 'ciri',
'mencirit': 'cirit',
'tercirit': 'cirit',
'menciritkan': 'cirit',
'cirit-birit': 'cirit',
'mencita': 'cita',
'mencitakan': 'cita',
'mencitakannya': 'cita',
'mencitai': 'cita',
'cita-cita': 'cita',
'cita-citanya': 'cita',
'cita-citalah': 'cita',
'cita-citakan': 'cita',
'cita-citaku': 'cita',
'cita-citamu': 'cita',
'cita-cita-mu': 'cita',
'bercita-cita': 'cita',
'bercita-citanya': 'cita',
'bercita-citalah': 'cita',
'mencita-citakan': 'cita',
'mencita-citakannya': 'cita',
'citraan': 'citra',
'mencitrakan': 'citra',
'mencitrakannya': 'citra',
'ciuman': 'cium',
'ciumannya': 'cium',
'ciumanku': 'cium',
'ciumanmu': 'cium',
'pencium': 'cium',
'penciumnya': 'cium',
'penciuman': 'cium',
'mencium': 'cium',
'menciumnya': 'cium',
'menciumkan': 'cium',
'menciumi': 'cium',
'menciumku': 'cium',
'menciummu': 'cium',
'tercium': 'cium',
'terciumnya': 'cium',
'terciumlah': 'cium',
'menciuminya': 'cium',
'menciumimu': 'cium',
'berciuman': 'cium',
'berciumannya': 'cium',
'berciumanlah': 'cium',
'penciumannya': 'cium',
'penciumanan': 'cium',
'penciumanku': 'cium',
'mencium-cium': 'cium',
'mencium-ciumi': 'cium',
'menciut': 'ciut',
'menciutnya': 'ciut',
'menciutkan': 'ciut',
'menciutkannya': 'ciut',
'penciutan': 'ciut',
'berciut-ciut': 'ciut',
'menciut-ciut': 'ciut',
'mencoaki': 'coak',
'mencoang': 'coang',
'tercoang': 'coang',
'bercoang': 'coang',
'bercoangan': 'coang',
'mencoangkan': 'coang',
'mencoang-coang': 'coang',
'cobaan': 'coba',
'cobaannya': 'coba',
'cobaan-mu': 'coba',
'mencoba': 'coba',
'mencobanya': 'coba',
'mencobalah': 'coba',
'mencobakan': 'coba',
'mencobai': 'coba',
'percobaan': 'coba',
'percobaannya': 'coba',
'percobaanlah': 'coba',
'pencobaan': 'coba',
'pencobaannya': 'coba',
'mencoba-coba': 'coba',
'mencoba-cobanya': 'coba',
'pencoblos': 'coblos',
'pencoblosnya': 'coblos',
'pencoblosan': 'coblos',
'mencoblos': 'coblos',
'mencoblosnya': 'coblos',
'mencobloskan': 'coblos',
'mencoblosi': 'coblos',
'mencoblosan': 'coblos',
'pencoblosannya': 'coblos',
'mencocok': 'cocok',
'mencocokkan': 'cocok',
'mencocokkannya': 'cocok',
'mencocoki': 'cocok',
'mencocokan': 'cocok',
'tercocok': 'cocok',
'kecocokan': 'cocok',
'kecocokannya': 'cocok',
'pencocokan': 'cocok',
'pencocokannya': 'cocok',
'mencocok-cocok': 'cocok',
'mencocok-cocokkan': 'cocok',
'mencocok-cocokan': 'cocok',
'bercocok tanam': 'cocok tanam',
'mencocol': 'cocol',
'mencocolnya': 'cocol',
'mencocolkan': 'cocol',
'mencocor': 'cocor',
'mencocornya': 'cocor',
'mencocorkan': 'cocor',
'mencocorkannya': 'cocor',
'mencodak': 'codak',
'mencodakkan': 'codak',
'tercogok': 'cogok',
'mencogok': 'cogok',
'cokekan': 'cokek',
'mencokek': 'cokek',
'kecokelatan': 'cokelat',
'kecokelatannya': 'cokelat',
'kecokelat-cokelatan': 'cokelat',
'mencoket': 'coket',
'mencokok': 'cokok',
'mencokoknya': 'cokok',
'mencokoki': 'cokok',
'bercokol': 'cokol',
'bercokolnya': 'cokol',
'mencokolkan': 'cokol',
'colak caling': 'colak',
'secolek': 'colek',
'colekan': 'colek',
'mencolek': 'colek',
'mencoleknya': 'colek',
'mencolekkan': 'colek',
'pencolek': 'colek',
'pencolekan': 'colek',
'mencolek-colek': 'colek',
'mencoleng': 'coleng',
'pencoleng': 'coleng',
'pencolengnya': 'coleng',
'pencolengan': 'coleng',
'mencolok': 'colok',
'mencoloknya': 'colok',
'mencolokkan': 'colok',
'mencolokkannya': 'colok',
'mencolokan': 'colok',
'tercolok': 'colok',
'mencoloki': 'colok',
'mencolong': 'colong',
'kecolongan': 'colong',
'kecolongannya': 'colong',
'kecolonganlah': 'colong',
'mencolot': 'colot',
'comelan': 'comel',
'mencomel': 'comel',
'pencomel': 'comel',
'mencomeli': 'comel',
'pencomelan': 'comel',
'comotan': 'comot',
'mencomot': 'comot',
'mencomotnya': 'comot',
'mencomoti': 'comot',
'comot-comot': 'comot',
'bercompang-camping': 'compang-camping',
'menconcong': 'concong',
'tercondong': 'condong',
'kecondongan': 'condong',
'kecondongannya': 'condong',
'mencondongkan': 'condong',
'berkecondongan': 'condong',
'condong-mondong': 'condong',
'menconet': 'conet',
'mencongak': 'congak',
'mencongakkan': 'congak',
'congak-cangit': 'congak',
'tercongget-congget': 'congget',
'terconggok': 'conggok',
'menconggokkan': 'conggok',
'kecongkakan': 'congkak',
'mencongklang': 'congklang',
'mencongkong': 'congkong',
'mencongok': 'congok',
'mencongol': 'congol',
'menconteng': 'conteng',
'terconteng': 'conteng',
'mencontengkan': 'conteng',
'berconteng-conteng': 'conteng',
'menconteng-conteng': 'conteng',
'percontoh': 'contoh',
'percontohan': 'contoh',
'mencontoh': 'contoh',
'mencontohnya': 'contoh',
'mencontohkan': 'contoh',
'mencontohkannya': 'contoh',
'mencontohi': 'contoh',
'mencontohan': 'contoh',
'pemercontoh': 'contoh',
'percontohannya': 'contoh',
'pemercontohan': 'contoh',
'mempercontohkan': 'contoh',
'mencopet': 'copet',
'pencopet': 'copet',
'pencopetnya': 'copet',
'pencopetan': 'copet',
'kecopetan': 'copet',
'kecopetannya': 'copet',
'pencopetannya': 'copet',
'mencopot': 'copot',
'mencopotnya': 'copot',
'mencopotkan': 'copot',
'mencopoti': 'copot',
'mencopotinya': 'copot',
'pencopotan': 'copot',
'pencopotannya': 'copot',
'pencopotanlah': 'copot',
'coran': 'cor',
'corannya': 'cor',
'mengecor': 'cor',
'mengecornya': 'cor',
'pengecoran': 'cor',
'pengecorannya': 'cor',
'mencorek': 'corek',
'mencorekan': 'corek',
'coretan': 'coret',
'coretannya': 'coret',
'mencoret': 'coret',
'mencoretnya': 'coret',
'mencoretkan': 'coret',
'mencoreti': 'coret',
'mencoretinya': 'coret',
'pencoretan': 'coret',
'pencoretannya': 'coret',
'coret-coret': 'coret',
'coret-coretnya': 'coret',
'coret-coretan': 'coret',
'mencorong': 'corong',
'mencorongkan': 'corong',
'mencorotkan': 'corot',
'mencotok': 'cotok',
'mencuaikan': 'cuai',
'cuang-caing': 'cuang',
'bercuang-caing': 'cuang',
'tercuar': 'cuar',
'mencuar': 'cuar',
'mencuarkan': 'cuar',
'cuatan': 'cuat',
'mencuat': 'cuat',
'mencuatnya': 'cuat',
'mencuatlah': 'cuat',
'mencuatkan': 'cuat',
'bercuatan': 'cuat',
'cubitan': 'cubit',
'cubitannya': 'cubit',
'secubit': 'cubit',
'mencubit': 'cubit',
'mencubitnya': 'cubit',
'mencubiti': 'cubit',
'mencubitku': 'cubit',
'mencubit-cubit': 'cubit',
'cubung-cubung': 'cubung',
'mencuca': 'cuca',
'tercuci': 'cuci',
'mencuci': 'cuci',
'mencucinya': 'cuci',
'mencucilah': 'cuci',
'mencucikan': 'cuci',
'mencucikannya': 'cuci',
'mencucian': 'cuci',
'pencuci': 'cuci',
'pencucinya': 'cuci',
'pencucian': 'cuci',
'pencuciannya': 'cuci',
'bercucu': 'cucu',
'mencucuh': 'cucuh',
'mencucuh-cucuh': 'cucuh',
'mencucuh-cucuhkan': 'cucuh',
'mencucup': 'cucup',
'mencucut': 'cucut',
'mencugatkan': 'cugat',
'mencuik': 'cuik',
'secuil': 'cuil',
'secuilnya': 'cuil',
'mencuil': 'cuil',
'mencuili': 'cuil',
'mencuit': 'cuit',
'mencuitnya': 'cuit',
'mencuitkan': 'cuit',
'mencuitkannya': 'cuit',
'bercuit-cuit': 'cuit',
'bercukai': 'cukai',
'mencukai': 'cukai',
'bercuki': 'cuki',
'cukilan': 'cukil',
'cukilannya': 'cukil',
'mencukil': 'cukil',
'mencukilnya': 'cukil',
'mencukongi': 'cukong',
'percukongan': 'cukong',
'secukup': 'cukup',
'secukupnya': 'cukup',
'cukupan': 'cukup',
'kecukupan': 'cukup',
'kecukupannya': 'cukup',
'mencukupi': 'cukup',
'mencukupinya': 'cukup',
'mencukupimu': 'cukup',
'mencukupkan': 'cukup',
'mencukupkannya': 'cukup',
'berkecukupan': 'cukup',
'menculak': 'culak',
'keculasan': 'culas',
'penculik': 'culik',
'penculiknya': 'culik',
'penculikkan': 'culik',
'penculikan': 'culik',
'penculikku': 'culik',
'menculik': 'culik',
'menculiknya': 'culik',
'menculiki': 'culik',
'menculikan': 'culik',
'menculikmu': 'culik',
'penculikannya': 'culik',
'culik-culik': 'culik',
'percuma': 'cuma',
'percumanya': 'cuma',
'percumalah': 'cuma',
'bercuma': 'cuma',
'cuma-cuma': 'cuma',
'mempercumakan': 'cuma',
'cumbuan': 'cumbu',
'cumbuannya': 'cumbu',
'mencumbu': 'cumbu',
'mencumbunya': 'cumbu',
'mencumbui': 'cumbu',
'mencumbuku': 'cumbu',
'mencumbumu': 'cumbu',
'bercumbu': 'cumbu',
'bercumbulah': 'cumbu',
'mencumbuinya': 'cumbu',
'percumbuan': 'cumbu',
'percumbuannya': 'cumbu',
'bercumbu-cumbu': 'cumbu',
'bercumbu-cumbuan': 'cumbu',
'mencunam': 'cunam',
'pecundang': 'cundang',
'pecundangnya': 'cundang',
'pecundangi': 'cundang',
'kecundang': 'cundang',
'kecundangi': 'cundang',
'tercundang': 'cundang',
'mencundang': 'cundang',
'mencundangi': 'cundang',
'terkecundang': 'cundang',
'mengecundang': 'cundang',
'mengecundangi': 'cundang',
'mempecundang': 'cundang',
'mempecundangi': 'cundang',
'mempecundanginya': 'cundang',
'mengecundanginya': 'cundang',
'bercunduk': 'cunduk',
'tercungap': 'cungap',
'mencungap': 'cungap',
'cungap-cangip': 'cungap',
'tercungap-cungap': 'cungap',
'cungkilan': 'cungkil',
'cungkilannya': 'cungkil',
'mencungkil': 'cungkil',
'mencungkilnya': 'cungkil',
'pencungkil': 'cungkil',
'pencungkilan': 'cungkil',
'mencungul': 'cungul',
'tercupai': 'cupai',
'mencupaikan': 'cupai',
'mencupak': 'cupak',
'mencupang': 'cupang',
'mencupar': 'cupar',
'kecupetan': 'cupet',
'bercuping': 'cuping',
'cuplikan': 'cuplik',
'cuplikannya': 'cuplik',
'mencuplik': 'cuplik',
'mencuplikan': 'cuplik',
'cupu-cupu': 'cupu',
'bercura': 'cura',
'bercura-cura': 'cura',
'bercura-bura': 'cura',
'curahan': 'curah',
'tercurah': 'curah',
'tercurahnya': 'curah',
'tercurahkan': 'curah',
'mencurah': 'curah',
'mencurahkan': 'curah',
'mencurahkannya': 'curah',
'mencurahi': 'curah',
'pencurahan': 'curah',
'curaian': 'curai',
'mencuraikan': 'curai',
'mencuram': 'curam',
'mencurangi': 'curang',
'mencuranginya': 'curang',
'kecurangan': 'curang',
'kecurangannya': 'curang',
'kecuranganlah': 'curang',
'mencurat': 'curat',
'mencureng': 'cureng',
'curian': 'curi',
'curiannya': 'curi',
'mencuri': 'curi',
'mencurinya': 'curi',
'mencurilah': 'curi',
'mencurikan': 'curi',
'mencurian': 'curi',
'pencuri': 'curi',
'pencurinya': 'curi',
'pencurian': 'curi',
'kecurian': 'curi',
'pencuriannya': 'curi',
'mencuri-curi': 'curi',
'bercuriga': 'curiga',
'mencurigai': 'curiga',
'mencurigainya': 'curiga',
'mencurigaiku': 'curiga',
'kecurigaan': 'curiga',
'kecurigaannya': 'curiga',
'mencurigakan': 'curiga',
'mencurigakannya': 'curiga',
'mencurigakanlah': 'curiga',
'mencuru': 'curu',
'mengedab': 'dab',
'mendabak': 'dabak',
'mendabakan': 'dabak',
'mendabih': 'dabih',
'pendabihan': 'dabih',
'mendabik': 'dabik',
'berdabung': 'dabung',
'mendabung': 'dabung',
'berdabus': 'dabus',
'mendacin': 'dacin',
'berdada ruah': 'dada ruah',
'pendadah': 'dadah',
'pendadahan': 'dadah',
'dadakan': 'dadak',
'dadakannya': 'dadak',
'mendadak': 'dadak',
'mendadaknya': 'dadak',
'pendadakan': 'dadak',
'pendadaran': 'dadar',
'terdadek': 'dadek',
'berdadu': 'dadu',
'mendaduh': 'daduh',
'mendaduhkan': 'daduh',
'pendaduk': 'daduk',
'mendaduk': 'daduk',
'berdadung': 'dadung',
'mendadung': 'dadung',
'mendadungkan': 'dadung',
'kedaerahan': 'daerah',
'kedaerahannya': 'daerah',
'mendaftarhitamkan': 'daftar hitam',
'mendaftar': 'daftar',
'mendaftarnya': 'daftar',
'mendaftarlah': 'daftar',
'mendaftarkan': 'daftar',
'mendaftarkannya': 'daftar',
'mendaftaran': 'daftar',
'pendaftar': 'daftar',
'pendaftarnya': 'daftar',
'pendaftarkan': 'daftar',
'pendaftaran': 'daftar',
'terdaftar': 'daftar',
'terdaftarnya': 'daftar',
'terdaftarlah': 'daftar',
'terdaftarkan': 'daftar',
'pendaftarannya': 'daftar',
'mendaga': 'daga',
'mendagakan': 'daga',
'pendaga': 'daga',
'pendagaan': 'daga',
'dagangan': 'dagang',
'dagangannya': 'dagang',
'daganganku': 'dagang',
'pedagang': 'dagang',
'pedagangnya': 'dagang',
'pedaganglah': 'dagang',
'pedagangan': 'dagang',
'berdagang': 'dagang',
'berdagangnya': 'dagang',
'berdaganglah': 'dagang',
'berdagangan': 'dagang',
'mendagang': 'dagang',
'mendagangkan': 'dagang',
'pendagang': 'dagang',
'pendagangan': 'dagang',
'perdagangan': 'dagang',
'perdagangannya': 'dagang',
'perdaganganlah': 'dagang',
'perdagangankan': 'dagang',
'perdaganganan': 'dagang',
'memperdagangkan': 'dagang',
'memperdagangkannya': 'dagang',
'berdagang': 'dagang',
'dagelan': 'dagel',
'mendagel': 'dagel',
'mendagi': 'dagi',
'pendagi': 'dagi',
'pendagian': 'dagi',
'mendahaga': 'dahaga',
'berdahan': 'dahan',
'mendahan': 'dahan',
'berdahanam': 'dahanam',
'mendahsyat': 'dahsyat',
'kedahsyatan': 'dahsyat',
'kedahsyatannya': 'dahsyat',
'memperdahsyat': 'dahsyat',
'mendahsyatkan': 'dahsyat',
'pendahulu': 'dahulu',
'pendahulunya': 'dahulu',
'pendahuluan': 'dahulu',
'pendahuluku': 'dahulu',
'pendahulumu': 'dahulu',
'terdahulu': 'dahulu',
'terdahulunya': 'dahulu',
'terdahului': 'dahulu',
'mendahului': 'dahulu',
'mendahuluinya': 'dahulu',
'mendahuluilah': 'dahulu',
'mendahuluiku': 'dahulu',
'mendahuluimu': 'dahulu',
'kedahuluan': 'dahulu',
'bersidahulu': 'dahulu',
'pendahuluannya': 'dahulu',
'mendahulukan': 'dahulu',
'mendahulukannya': 'dahulu',
'dahulu-mendahului': 'dahulu',
'berdahulu-dahuluan': 'dahulu',
'kedaifan': 'daif',
'mendaifkan': 'daif',
'dakian': 'daki',
'berdaki': 'daki',
'pendaki': 'daki',
'pendakinya': 'daki',
'pendakian': 'daki',
'mendaki': 'daki',
'mendakinya': 'daki',
'mendakian': 'daki',
'mendakimu': 'daki',
'terdaki': 'daki',
'pendakiannya': 'daki',
'pendakianku': 'daki',
'pendakianmu': 'daki',
'mendakikan': 'daki',
'dakwaan': 'dakwa',
'dakwaannya': 'dakwa',
'terdakwa': 'dakwa',
'terdakwanya': 'dakwa',
'terdakwalah': 'dakwa',
'terdakwai': 'dakwa',
'berdakwa': 'dakwa',
'mendakwa': 'dakwa',
'mendakwanya': 'dakwa',
'mendakwakan': 'dakwa',
'pendakwa': 'dakwa',
'pendakwaan': 'dakwa',
'mendakwai': 'dakwa',
'pendakwaannya': 'dakwa',
'memperdakwakan': 'dakwa',
'dalaman': 'dalam',
'dalamannya': 'dalam',
'mendalam': 'dalam',
'mendalamnya': 'dalam',
'mendalamkan': 'dalam',
'mendalami': 'dalam',
'mendalaman': 'dalam',
'pedalaman': 'dalam',
'pedalamannya': 'dalam',
'kedalaman': 'dalam',
'kedalamannya': 'dalam',
'kedalamanan': 'dalam',
'mendalaminya': 'dalam',
'pendalaman': 'dalam',
'pendalamannya': 'dalam',
'pendalamanan': 'dalam',
'memperdalam': 'dalam',
'memperdalamnya': 'dalam',
'memperdalami': 'dalam',
'dalam-dalam': 'dalam',
'dalam-dalamnya': 'dalam',
'berdalam-dalam': 'dalam',
'sedalam-dalamnya': 'dalam',
'sedalam-dalamnyanya': 'dalam',
'pedalang': 'dalang',
'pedalangan': 'dalang',
'mendalang': 'dalang',
'mendalangnya': 'dalang',
'mendalangi': 'dalang',
'pedalangannya': 'dalang',
'mendalanginya': 'dalang',
'mendalangkan': 'dalang',
'berdalil': 'dalil',
'mendalilkan': 'dalil',
'dam-dam': 'dam',
'dam-daman': 'dam',
'mendamak': 'damak',
'pendamar': 'damar',
'pendamaran': 'damar',
'berdamar': 'damar',
'mendamar': 'damar',
'pedamaran': 'damar',
'dambaan': 'damba',
'dambaannya': 'damba',
'mendamba': 'damba',
'mendambakan': 'damba',
'mendambakannya': 'damba',
'pendamba': 'damba',
'pendambaan': 'damba',
'berdambin': 'dambin',
'mendamik': 'damik',
'mendampak': 'dampak',
'mendampakkan': 'dampak',
'mendampakan': 'dampak',
'berdampak': 'dampak',
'berdampaknya': 'dampak',
'berdampakan': 'dampak',
'mendampar': 'dampar',
'mendamparkan': 'dampar',
'mendamparkannya': 'dampar',
'terdampar': 'dampar',
'terdamparnya': 'dampar',
'keterdamparan': 'dampar',
'berdampil': 'dampil',
'mendampilkan': 'dampil',
'dampratan': 'damprat',
'dampratannya': 'damprat',
'mendamprat': 'damprat',
'mendampratnya': 'damprat',
'berdampung-dampung': 'dampung',
'pendana': 'dana',
'pendananya': 'dana',
'pendanaan': 'dana',
'mendanai': 'dana',
'mendanainya': 'dana',
'pendanaannya': 'dana',
'mendanau': 'danau',
'pendangdut': 'dangdut',
'berdangdut': 'dangdut',
'mendangir': 'dangir',
'berdangka': 'dangka',
'terdangka-dangka': 'dangka',
'dangkalan': 'dangkal',
'kedangkalan': 'dangkal',
'kedangkalannya': 'dangkal',
'pendangkalan': 'dangkal',
'pendangkalannya': 'dangkal',
'pendangkalanan': 'dangkal',
'mendangkalkan': 'dangkal',
'mendangkar': 'dangkar',
'berdangkung': 'dangkung',
'mendangkung': 'dangkung',
'mendanguk': 'danguk',
'berdanguk': 'danguk',
'terdanguk': 'danguk',
'berdansanak': 'dansanak',
'sedapat': 'dapat',
'sedapatnya': 'dapat',
'dapatan': 'dapat',
'terdapat': 'dapat',
'terdapatnya': 'dapat',
'terdapatlah': 'dapat',
'terdapati': 'dapat',
'berdapat': 'dapat',
'berdapatan': 'dapat',
'mendapat': 'dapat',
'mendapatnya': 'dapat',
'mendapatkan': 'dapat',
'mendapatkannya': 'dapat',
'mendapati': 'dapat',
'mendapatan': 'dapat',
'pendapat': 'dapat',
'pendapatnya': 'dapat',
'pendapatlah': 'dapat',
'pendapatkan': 'dapat',
'pendapatkannya': 'dapat',
'pendapatan': 'dapat',
'pendapatku': 'dapat',
'pendapatmu': 'dapat',
'mendapatinya': 'dapat',
'mendapatikan': 'dapat',
'mendapatiku': 'dapat',
'kedapatan': 'dapat',
'kedapatannya': 'dapat',
'kedapatanlah': 'dapat',
'kedapatanan': 'dapat',
'pendapatannya': 'dapat',
'pendapatanan': 'dapat',
'pendapatanmu': 'dapat',
'mendapatkankan': 'dapat',
'mendapatkanan': 'dapat',
'mendapatkanku': 'dapat',
'memperdapat': 'dapat',
'sedapat-dapatnya': 'dapat',
'perdaraan': 'dara',
'mendarab': 'darab',
'berdarah': 'darah',
'berdarahnya': 'darah',
'pendarah': 'darah',
'pendarahan': 'darah',
'mendarah': 'darah',
'mendarahi': 'darah',
'mendarahan': 'darah',
'perdarahan': 'darah',
'perdarahannya': 'darah',
'pendarahannya': 'darah',
'mendaras': 'daras',
'mendaraskan': 'daras',
'pendarasan': 'daras',
'daratan': 'darat',
'daratannya': 'darat',
'pendarat': 'darat',
'pendaratnya': 'darat',
'pendaratan': 'darat',
'mendarat': 'darat',
'mendaratnya': 'darat',
'mendaratlah': 'darat',
'mendaratkan': 'darat',
'mendaratkannya': 'darat',
'mendarati': 'darat',
'mendaratan': 'darat',
'pendaratannya': 'darat',
'pendaratanmu': 'darat',
'sedari': 'dari',
'mendarmabaktikan': 'darmabakti',
'berdarmawisata': 'darmawisata',
'sedarun': 'darun',
'mendaruratkan': 'darurat',
'berdasi': 'dasi',
'mendasun': 'dasun',
'mendata': 'data',
'mendatanya': 'data',
'mendatakan': 'data',
'mendatakannya': 'data',
'mendataan': 'data',
'pendataan': 'data',
'pendataannya': 'data',
'pendatang': 'datang',
'pendatangnya': 'datang',
'pendatangan': 'datang',
'berdatang': 'datang',
'berdatangnya': 'datang',
'berdatangkan': 'datang',
'berdatangan': 'datang',
'mendatang': 'datang',
'mendatangnya': 'datang',
'mendatanglah': 'datang',
'mendatangkan': 'datang',
'mendatangkannya': 'datang',
'mendatangi': 'datang',
'mendatangan': 'datang',
'mendatanginya': 'datang',
'mendatangiku': 'datang',
'mendatangimu': 'datang',
'kedatangan': 'datang',
'kedatangannya': 'datang',
'kedatangani': 'datang',
'kedatanganan': 'datang',
'kedatanganku': 'datang',
'kedatanganmu': 'datang',
'pendatangannya': 'datang',
'pendatanganan': 'datang',
'berdatangannya': 'datang',
'berdatanganlah': 'datang',
'berdatanganan': 'datang',
'mendatangkankan': 'datang',
'mendatangkanku': 'datang',
'mendatangkanmu': 'datang',
'datang-datang': 'datang',
'berdatang sembah': 'datang',
'datang-mendatangi': 'datang',
'sedatar': 'datar',
'dataran': 'datar',
'datarannya': 'datar',
'mendatar': 'datar',
'mendatarnya': 'datar',
'mendatarkan': 'datar',
'pendataran': 'datar',
'pendatarannya': 'datar',
'kedatuan': 'datu',
'berdatuk': 'datuk',
'mendaur ulang': 'daur ulang',
'pendaurulangan': 'daur ulang',
'berdawai': 'dawai',
'berdawat': 'dawat',
'berdaya guna': 'daya guna',
'kedayagunaan': 'daya guna',
'pendayagunaan': 'daya guna',
'pendayagunaannya': 'daya guna',
'mendayagunakan': 'daya guna',
'mendayagunakannya': 'daya guna',
'berdaya upaya': 'daya upaya',
'pendayaupayaan': 'daya upaya',
'pendayang': 'dayang',
'pendayangan': 'dayang',
'perdayangan': 'dayang',
'dayang-dayang': 'dayang',
'dayang-dayangnya': 'dayang',
'mendayu': 'dayu',
'terdayuh': 'dayuh',
'terdayuk': 'dayuk',
'mendayus': 'dayus',
'mendebah': 'debah',
'debak-debuk': 'debak',
'berdebat': 'debat',
'berdebatnya': 'debat',
'berdebatlah': 'debat',
'berdebatan': 'debat',
'pendebat': 'debat',
'mendebat': 'debat',
'mendebatnya': 'debat',
'mendebatkan': 'debat',
'mendebatkannya': 'debat',
'mendebatmu': 'debat',
'perdebatan': 'debat',
'perdebatannya': 'debat',
'perdebatankan': 'debat',
'memperdebatkan': 'debat',
'memperdebatkannya': 'debat',
'mendebik': 'debik',
'pendebitan': 'debit',
'mendebitkan': 'debit',
'berdebum': 'debum',
'berdebus': 'debus',
'berdebut': 'debut',
'berdecak-decak': 'decak',
'mendecap-decap': 'decap',
'berdecap-decap': 'decap',
'berdecup': 'decup',
'berdecup-decup': 'decup',
'mendecur': 'decur',
'berdecut': 'decut',
'berdecut-decut': 'decut',
'terdedah': 'dedah',
'pendedahan': 'dedah',
'mendedahkan': 'dedah',
'keterdedahan': 'dedah',
'berdedai-dedai': 'dedai',
'berdedak': 'dedak',
'mendedas': 'dedas',
'mendedau': 'dedau',
'mendedel': 'dedel',
'mendeder': 'deder',
'mendederkan': 'deder',
'pendederan': 'deder',
'mendedes': 'dedes',
'berdefile': 'defile',
'pendefinisian': 'definisi',
'mendefinisikan': 'definisi',
'mendefinisikannya': 'definisi',
'mendefinisikanku': 'definisi',
'deg-degan': 'deg',
'deg-degannya': 'deg',
'deg-deganku': 'deg',
'mendegam': 'degam',
'berdegam': 'degam',
'mendegam-degam': 'degam',
'berdegap': 'degap',
'degap-degap': 'degap',
'berdegap-degap': 'degap',
'berdegar-degar': 'degar',
'mendegil': 'degil',
'mendegilkan': 'degil',
'kedegilan': 'degil',
'kedegilannya': 'degil',
'berdeging': 'deging',
'berdegum': 'degum',
'mendeham': 'deham',
'berdeham': 'deham',
'berdeham-deham': 'deham',
'berdekah-dekah': 'dekah',
'berdekak-dekak': 'dekak',
'berdekam': 'dekam',
'mendekam': 'dekam',
'mendekamnya': 'dekam',
'mendekamkan': 'dekam',
'dekapan': 'dekap',
'dekapannya': 'dekap',
'dekapanku': 'dekap',
'mendekap': 'dekap',
'mendekapnya': 'dekap',
'mendekapkan': 'dekap',
'mendekapku': 'dekap',
'berdekap': 'dekap',
'berdekapan': 'dekap',
'sedekapan': 'dekap',
'sependekap': 'dekap',
'memperdekap': 'dekap',
'berdekap-dekapan': 'dekap',
'pendekar': 'dekar',
'pendekarnya': 'dekar',
'pendekaran': 'dekar',
'mendekar': 'dekar',
'mendekari': 'dekar',
'mendekat': 'dekat',
'mendekatnya': 'dekat',
'mendekatlah': 'dekat',
'mendekatkan': 'dekat',
'mendekatkannya': 'dekat',
'mendekati': 'dekat',
'mendekatan': 'dekat',
'berdekat': 'dekat',
'berdekati': 'dekat',
'berdekatan': 'dekat',
'terdekat': 'dekat',
'terdekatnya': 'dekat',
'terdekatlah': 'dekat',
'terdekatan': 'dekat',
'terdekatku': 'dekat',
'terdekatmu': 'dekat',
'kedekatan': 'dekat',
'kedekatannya': 'dekat',
'kedekatanku': 'dekat',
'mendekatinya': 'dekat',
'mendekatilah': 'dekat',
'mendekatian': 'dekat',
'mendekatiku': 'dekat',
'mendekatimu': 'dekat',
'berdekatannya': 'dekat',
'pendekatan': 'dekat',
'pendekatannya': 'dekat',
'pendekatanan': 'dekat',
'pendekatanku': 'dekat',
'pendekatanmu': 'dekat',
'dekat-dekat': 'dekat',
'dekat-dekatlah': 'dekat',
'dekat-dekatan': 'dekat',
'memperdekat': 'dekat',
'memperdekatkan': 'dekat',
'berdekat-dekat': 'dekat',
'berdekat-dekatan': 'dekat',
'mendeklarasikan': 'deklarasi',
'mendeklarasikannya': 'deklarasi',
'mendekolonisasi': 'dekolonisasi',
'pendekorasian': 'dekorasi',
'mendekretkan': 'dekret',
'berdeku': 'deku',
'berdekus': 'dekus',
'mendekus': 'dekus',
'berdekut': 'dekut',
'mendekut': 'dekut',
'berdelan': 'delan',
'berdelat-delat': 'delat',
'pendelegasian': 'delegasi',
'pendelegasiannya': 'delegasi',
'mendelegasikan': 'delegasi',
'mendelegasikannya': 'delegasi',
'mendelik': 'delik',
'mendelong': 'delong',
'mendemah': 'demah',
'berdembai-dembai': 'dembai',
'berdembam': 'dembam',
'berdembun': 'dembun',
'berdembun-dembun': 'dembun',
'mendemik': 'demik',
'sedemikian': 'demikian',
'sedemikianlah': 'demikian',
'mendemiliterisasi': 'demiliterisasi',
'pedemo': 'demo',
'mendemo': 'demo',
'mendemonya': 'demo',
'mendemokan': 'demo',
'mendemokannya': 'demo',
'mendemobilisasi': 'demobilisasi',
'pendemokrasian': 'demokrasi',
'mendemokrasikan': 'demokrasi',
'berdempak': 'dempak',
'berdempang-dempang': 'dempang',
'berdempet': 'dempet',
'berdempetan': 'dempet',
'mendempetkan': 'dempet',
'berdempet-dempet': 'dempet',
'berdempet-dempetan': 'dempet',
'berdempok': 'dempok',
'terdempok': 'dempok',
'dempulan': 'dempul',
'mendempul': 'dempul',
'berdencing-dencing': 'dencing',
'dendaan': 'denda',
'mendenda': 'denda',
'mendendanya': 'denda',
'pendendaan': 'denda',
'pendendam': 'dendam',
'mendendam': 'dendam',
'berdendam': 'dendam',
'mendendami': 'dendam',
'kedendaman': 'dendam',
'mendendamkan': 'dendam',
'berdendam-dendaman': 'dendam',
'pendendang': 'dendang',
'berdendang': 'dendang',
'mendendangkan': 'dendang',
'mendendangkannya': 'dendang',
'mendendeng': 'dendeng',
'berdengap': 'dengap',
'berdengar': 'dengar',
'terdengar': 'dengar',
'terdengarnya': 'dengar',
'terdengarlah': 'dengar',
'mendengar': 'dengar',
'mendengarnya': 'dengar',
'mendengarkan': 'dengar',
'mendengarkannya': 'dengar',
'mendengari': 'dengar',
'mendengaran': 'dengar',
'mendengarku': 'dengar',
'mendengarmu': 'dengar',
'pendengar': 'dengar',
'pendengarnya': 'dengar',
'pendengaran': 'dengar',
'pendengarku': 'dengar',
'kedengaran': 'dengar',
'kedengarannya': 'dengar',
'pendengarannya': 'dengar',
'pendengaranlah': 'dengar',
'pendengaranan': 'dengar',
'pendengaranku': 'dengar',
'pendengaranmu': 'dengar',
'mendengarkankan': 'dengar',
'mendengarkanku': 'dengar',
'mendengarkanmu': 'dengar',
'dengar-dengaran': 'dengar',
'memperdengarkan': 'dengar',
'memperdengarkannya': 'dengar',
'mendengar-dengar': 'dengar',
'terdengih-dengih': 'dengih',
'mendenging': 'denging',
'berdenging': 'denging',
'berdengkang-dengkang': 'dengkang',
'mendengki': 'dengki',
'berdengki': 'dengki',
'pendengki': 'dengki',
'pendengkinya': 'dengki',
'kedengkian': 'dengki',
'kedengkiannya': 'dengki',
'kedengkik': 'dengkik',
'mendengkul': 'dengkul',
'berdengkung': 'dengkung',
'mendengkung': 'dengkung',
'mendengkus': 'dengkus',
'berdengkus': 'dengkus',
'mendengu': 'dengu',
'berdengu': 'dengu',
'terdenguk': 'denguk',
'mendenguk': 'denguk',
'berdengut': 'dengut',
'mendengut': 'dengut',
'berdengut-dengut': 'dengut',
'mendengut-dengut': 'dengut',
'dentaman': 'dentam',
'berdentam': 'dentam',
'berdentang': 'dentang',
'berdentang-dentang': 'dentang',
'berdentung': 'dentung',
'berdentung-dentung': 'dentung',
'denyitan': 'denyit',
'berdenyit': 'denyit',
'denyutan': 'denyut',
'denyutannya': 'denyut',
'mendenyut': 'denyut',
'mendenyutkan': 'denyut',
'berdenyut': 'denyut',
'berdenyutnya': 'denyut',
'berdenyut-denyut': 'denyut',
'mengedep': 'dep',
'mengedepkan': 'dep',
'mengedepan': 'dep',
'mendepa': 'depa',
'mendepakan': 'depa',
'berdepak-depak': 'depak',
'mendepakkan': 'depak',
'terdepan': 'depan',
'terdepannya': 'depan',
'pengedepanan': 'depan',
'mengedepankan': 'depan',
'mengedepankannya': 'depan',
'mengedepankankan': 'depan',
'berdepan-depan': 'depan',
'mendepang': 'depang',
'mendepangkan': 'depang',
'mendepolitisasi': 'depolitisasi',
'mendeponir': 'deponir',
'mendeponirnya': 'deponir',
'mendeponirkannya': 'deponir',
'mendeponiran': 'deponir',
'mendeportasi': 'deportasi',
'mendeportasinya': 'deportasi',
'mendeportasikan': 'deportasi',
'pendepositoan': 'deposito',
'mendepositokan': 'deposito',
'mendepositokannya': 'deposito',
'mendeprok': 'deprok',
'mendepun': 'depun',
'mendera': 'dera',
'menderanya': 'dera',
'menderai': 'dera',
'menderaku': 'dera',
'deraian': 'derai',
'berderai': 'derai',
'menderaikan': 'derai',
'berderai-derai': 'derai',
'menderai-deraikan': 'derai',
'sederajat': 'derajat',
'sederajatnya': 'derajat',
'menyederajatkan': 'derajat',
'derakan': 'derak',
'berderak': 'derak',
'berderaknya': 'derak',
'berderak-derak': 'derak',
'menderak-derakkan': 'derak',
'menderang': 'derang',
'berderang': 'derang',
'sederap': 'derap',
'berderap': 'derap',
'berderaplah': 'derap',
'menderap': 'derap',
'menderapkan': 'derap',
'menderas': 'deras',
'menderasnya': 'deras',
'penderas': 'deras',
'penderasan': 'deras',
'berderau': 'derau',
'menderau': 'derau',
'menderau-derau': 'derau',
'berderau-derau': 'derau',
'menderek': 'derek',
'mendereknya': 'derek',
'penderekan': 'derek',
'menderes': 'deres',
'penderes': 'deres',
'penderesan': 'deres',
'berderik': 'derik',
'berderik-derik': 'derik',
'berderis': 'deris',
'menderis': 'deris',
'menderit': 'derit',
'berderit': 'derit',
'deritaan': 'derita',
'penderita': 'derita',
'penderitanya': 'derita',
'penderitaan': 'derita',
'terderita': 'derita',
'menderita': 'derita',
'menderitanya': 'derita',
'menderitalah': 'derita',
'menderitakan': 'derita',
'penderitaannya': 'derita',
'penderitaanku': 'derita',
'penderitaanmu': 'derita',
'bederma': 'derma',
'penderma': 'derma',
'pendermanya': 'derma',
'pendermaan': 'derma',
'mendermakan': 'derma',
'mendermakannya': 'derma',
'kedermawanan': 'dermawan',
'kedermawanannya': 'dermawan',
'menderu': 'deru',
'menderu-deru': 'deru',
'menderu-derukan': 'deru',
'berderuk': 'deruk',
'berderung-derung': 'derung',
'berderus-derus': 'derus',
'pedesaan': 'desa',
'pedesaannya': 'desa',
'kedesaan': 'desa',
'perdesaan': 'desa',
'perdesaannya': 'desa',
'kedesa-desaan': 'desa',
'mendesah': 'desah',
'berdesah': 'desah',
'mendesain': 'desain',
'mendesainnya': 'desain',
'mendesainkan': 'desain',
'berdesain': 'desain',
'pendesain': 'desain',
'pendesainnya': 'desain',
'pendesainan': 'desain',
'desakan': 'desak',
'desakannya': 'desak',
'desakanan': 'desak',
'terdesak': 'desak',
'terdesaknya': 'desak',
'berdesak': 'desak',
'berdesakkan': 'desak',
'berdesakkannya': 'desak',
'berdesakan': 'desak',
'mendesak': 'desak',
'mendesaknya': 'desak',
'mendesaklah': 'desak',
'mendesakkan': 'desak',
'mendesakkannya': 'desak',
'mendesakan': 'desak',
'mendesakku': 'desak',
'pendesakan': 'desak',
'berdesak-desakan': 'desak',
'berdesak-desakannya': 'desak',
'mendesar': 'desar',
'berdesar': 'desar',
'berdesarkan': 'desar',
'mendesas-desuskan': 'desas-desus',
'mendesau': 'desau',
'berdesau': 'desau',
'berdesik-desik': 'desik',
'mendesis': 'desis',
'mendesiskan': 'desis',
'mendeskripsikan': 'deskripsi',
'mendeskripsikannya': 'deskripsi',
'mendestabilisasi': 'destabilisasi',
'mendestabilisasikan': 'destabilisasi',
'berdesus': 'desus',
'mendesuskan': 'desus',
'berdesus-desus': 'desus',
'mendesus-desus': 'desus',
'mendesut': 'desut',
'mendetail': 'detail',
'mendetailnya': 'detail',
'mendetailkan': 'detail',
'mendetailkannya': 'detail',
'mendetailan': 'detail',
'mendetak': 'detak',
'mendetakkan': 'detak',
'berdetak': 'detak',
'berdetaknya': 'detak',
'mendetap-detap': 'detap',
'mendetar': 'detar',
'berdetar': 'detar',
'berdetas': 'detas',
'mendetasir': 'detasir',
'mendeteksi': 'deteksi',
'mendeteksinya': 'deteksi',
'terdeteksi': 'deteksi',
'terdeteksinya': 'deteksi',
'terdeteksilah': 'deteksi',
'pendeteksian': 'deteksi',
'pendeteksiannya': 'deteksi',
'berdetus': 'detus',
'mendevaluasi': 'devaluasi',
'mendevaluasikan': 'devaluasi',
'pendevaluasian': 'devaluasi',
'kedewaan': 'dewa',
'pendewaan': 'dewa',
'memperdewa': 'dewa',
'mendewakan': 'dewa',
'mendewakannya': 'dewa',
'memperdewakan': 'dewa',
'mendewa-dewakan': 'dewa',
'kedewasaan': 'dewasa',
'kedewasaannya': 'dewasa',
'kedewasaanku': 'dewasa',
'pendewasaan': 'dewasa',
'pendewasaannya': 'dewasa',
'mendewasakan': 'dewasa',
'mendewasakannya': 'dewasa',
'mendewasakanku': 'dewasa',
'kedewataan': 'dewata',
'mendewatakan': 'dewata',
'mendiakan': 'dia',
'mendiagnosis': 'diagnosis',
'mendiagnosisnya': 'diagnosis',
'mendiagnosisi': 'diagnosis',
'berdialog': 'dialog',
'berdialognya': 'dialog',
'berdialoglah': 'dialog',
'mendiani': 'dian',
'memperdiarkan': 'diar',
'mendiatkan': 'diat',
'mendidih': 'didih',
'mendidihnya': 'didih',
'mendidihlah': 'didih',
'mendidihkan': 'didih',
'mendidihkannya': 'didih',
'didikan': 'didik',
'didikannya': 'didik',
'mendidik': 'didik',
'mendidiknya': 'didik',
'mendidiki': 'didik',
'mendidikan': 'didik',
'mendidikmu': 'didik',
'pendidik': 'didik',
'pendidiknya': 'didik',
'pendidiklah': 'didik',
'pendidikkan': 'didik',
'pendidikan': 'didik',
'pendidikmu': 'didik',
'mendidis': 'didis',
'kedigdayaan': 'digdaya',
'kedigdayaannya': 'digdaya',
'pendigulan': 'digul',
'mendigulkan': 'digul',
'berdikit-dikit': 'dikit',
'sedikit-dikitnya': 'sedikit',
'berdiksa': 'diksa',
'kediktatoran': 'diktator',
'kediktatorannya': 'diktator',
'mendikte': 'dikte',
'mendiktenya': 'dikte',
'mendiktekan': 'dikte',
'mendiktekannya': 'dikte',
'mendilak': 'dilak',
'makanan': 'makan',
'makanannya': 'makan',
'makananlah': 'makan',
'makananan': 'makan',
'makananku': 'makan',
'makananmu': 'makan',
'memakan': 'makan',
'memakannya': 'makan',
'memakankan': 'makan',
'memakani': 'makan',
'memakanan': 'makan',
'memakanmu': 'makan',
'dimakan': 'makan',
'dimakannya': 'makan',
'dimakanlah': 'makan',
'dimakankan': 'makan',
'dimakani': 'makan',
'dimakanan': 'makan',
'pemakan': 'makan',
'pemakannya': 'makan',
'pemakanan': 'makan',
'termakan': 'makan',
'termakannya': 'makan',
'sepemakan': 'makan',
'makan-makan': 'makan',
'makan-makannya': 'makan',
'makan-makanlah': 'makan',
'makan-makanan': 'makan',
'makan-makanannya': 'makan',
'pendinamis': 'dinamis',
'kedinamisan': 'dinamis',
'mendinamiskan': 'dinamis',
'mendinamit': 'dinamit',
'mendinamitnya': 'dinamit',
'pendinamitan': 'dinamit',
'berdinas': 'dinas',
'kedinasan': 'dinas',
'kedinasannya': 'dinas',
'mendinaskan': 'dinas',
'berdinding': 'dinding',
'berdindingkan': 'dinding',
'pendinding': 'dinding',
'terdinding': 'dinding',
'mendinding': 'dinding',
'mendindingi': 'dinding',
'pendindingan': 'dinding',
'mendingin': 'dingin',
'mendinginnya': 'dingin',
'mendinginkan': 'dingin',
'mendinginkannya': 'dingin',
'pendingin': 'dingin',
'pendinginnya': 'dingin',
'pendinginan': 'dingin',
'kedinginan': 'dingin',
'kedinginannya': 'dingin',
'pendinginannya': 'dingin',
'berdingkit-dingkit': 'dingkit',
'sedini-dininya': 'dini',
'pemanggang': 'panggang',
'pemanggangnya': 'panggang',
'pemanggangan': 'panggang',
'panggangan': 'panggang',
'panggangannya': 'panggang',
'memanggang': 'panggang',
'memanggangnya': 'panggang',
'dipanggang': 'panggang',
'dipanggangnya': 'panggang',
'pemanggangannya': 'panggang',
'berdiplomasi': 'diplomasi',
'berdiplomasinya': 'diplomasi',
'kedirgantaraan': 'dirgantara',
'kedirgantaraannya': 'dirgantara',
'mendiris': 'diris',
'pendiris': 'diris',
'mendirus': 'dirus',
'pendirusan': 'dirus',
'mendiruskan': 'dirus',
'pendisko': 'disko',
'mendiskreditkan': 'diskredit',
'mendiskreditkannya': 'diskredit',
'mendiskriminasi': 'diskriminasi',
'mendiskriminasinya': 'diskriminasi',
'mendiskriminasikan': 'diskriminasi',
'mendiskriminasikannya': 'diskriminasi',
'mendiskualifikasikan': 'diskualifikasi',
'berdiskusi': 'diskusi',
'berdiskusinya': 'diskusi',
'berdiskusilah': 'diskusi',
'berdiskusikan': 'diskusi',
'mendiskusikan': 'diskusi',
'mendiskusikannya': 'diskusi',
'mendistribusi': 'distribusi',
'mendistribusinya': 'distribusi',
'mendistribusikan': 'distribusi',
'mendistribusikannya': 'distribusi',
'mendistribusian': 'distribusi',
'terdistribusi': 'distribusi',
'terdistribusinya': 'distribusi',
'terdistribusilah': 'distribusi',
'terdistribusikan': 'distribusi',
'terdistribusikannya': 'distribusi',
'pendistribusian': 'distribusi',
'pendistribusiannya': 'distribusi',
'penanam': 'tanam',
'penanamnya': 'tanam',
'penanamkan': 'tanam',
'penanaman': 'tanam',
'menanam': 'tanam',
'menanamnya': 'tanam',
'menanamlah': 'tanam',
'menanamkan': 'tanam',
'menanamkannya': 'tanam',
'menanami': 'tanam',
'menanaman': 'tanam',
'tanaman': 'tanam',
'tanamannya': 'tanam',
'tanamanan': 'tanam',
'tanamanku': 'tanam',
'ditanam': 'tanam',
'ditanamnya': 'tanam',
'ditanamlah': 'tanam',
'ditanamkan': 'tanam',
'ditanamkannya': 'tanam',
'ditanami': 'tanam',
'ditanaman': 'tanam',
'tertanam': 'tanam',
'tertanamnya': 'tanam',
'tertanamlah': 'tanam',
'tertanamkan': 'tanam',
'tertanami': 'tanam',
'menanaminya': 'tanam',
'bertanam': 'tanam',
'bertanamnya': 'tanam',
'bertanaman': 'tanam',
'penanamannya': 'tanam',
'penanamanan': 'tanam',
'menanamkankan': 'tanam',
'pertanaman': 'tanam',
'tanam-menanam': 'tanam',
'tanam-menanamnya': 'tanam',
'tanam-tanaman': 'tanam',
'mendiversifikasi': 'diversifikasi',
'mendiversifikasinya': 'diversifikasi',
'mendiversifikasikan': 'diversifikasi',
'mendiversifikasikannya': 'diversifikasi',
'pendiversifikasian': 'diversifikasi',
'mendobrak': 'dobrak',
'mendobraknya': 'dobrak',
'mendobrakkan': 'dobrak',
'pendobrak': 'dobrak',
'pendobraknya': 'dobrak',
'pendobrakkan': 'dobrak',
'pendobrakan': 'dobrak',
'mendodet': 'dodet',
'terdodong': 'dodong',
'kedodoran': 'dodor',
'kedodorannya': 'dodor',
'mendodos': 'dodos',
'berdogol': 'dogol',
'kedogolan': 'dogol',
'terdohok': 'dohok',
'berdokar': 'dokar',
'kedokteran': 'dokter',
'kedokterannya': 'dokter',
'kedokteranlah': 'dokter',
'kedokteranan': 'dokter',
'pendokumentasian': 'dokumentasi',
'pendokumentasiannya': 'dokumentasi',
'mendokumentasikan': 'dokumentasi',
'mendokumentasikannya': 'dokumentasi',
'dolanan': 'dolan',
'pendolaran': 'dolar',
'mendolarkan': 'dolar',
'mendominasi': 'dominasi',
'mendominasinya': 'dominasi',
'mendominasikan': 'dominasi',
'berdomisili': 'domisili',
'berdomisilinya': 'domisili',
'mendompak': 'dompak',
'berdompak': 'dompak',
'domplangan': 'domplang',
'domplengan': 'dompleng',
'pendompleng': 'dompleng',
'pendomplengan': 'dompleng',
'mendompleng': 'dompleng',
'mendomplengnya': 'dompleng',
'mendomplengkan': 'dompleng',
'mendomplengi': 'dompleng',
'pendomplengannya': 'dompleng',
'sedompol': 'dompol',
'dompolan': 'dompol',
'berdompol': 'dompol',
'mendoncang': 'doncang',
'dondangan': 'dondang',
'mendondangkan': 'dondang',
'mendonder': 'donder',
'sedondon': 'dondon',
'mendondon': 'dondon',
'mendongak': 'dongak',
'mendongakkan': 'dongak',
'mendongakkannya': 'dongak',
'dongengan': 'dongeng',
'mendongeng': 'dongeng',
'mendongengnya': 'dongeng',
'mendongengkan': 'dongeng',
'mendongengi': 'dongeng',
'pendongeng': 'dongeng',
'pendongengnya': 'dongeng',
'mendongkak': 'dongkak',
'mendongkakkan': 'dongkak',
'dongkelan': 'dongkel',
'mendongkel': 'dongkel',
'mendongkelnya': 'dongkel',
'pendongkok': 'dongkok',
'pendongkol': 'dongkol',
'mendongkol': 'dongkol',
'mendongkolkan': 'dongkol',
'mendongkrak': 'dongkrak',
'mendongkraknya': 'dongkrak',
'mendongkrakkan': 'dongkrak',
'mendongkrakan': 'dongkrak',
'pendongkrak': 'dongkrak',
'pendongkraknya': 'dongkrak',
'pendongkrakan': 'dongkrak',
'terdongkrak': 'dongkrak',
'terdongkraknya': 'dongkrak',
'mendongsok': 'dongsok',
'mengedor': 'dor',
'dor-doran': 'dor',
'mendornai': 'dorna',
'dorongan': 'dorong',
'dorongannya': 'dorong',
'terdorong': 'dorong',
'terdorongnya': 'dorong',
'mendorong': 'dorong',
'mendorongnya': 'dorong',
'mendoronglah': 'dorong',
'mendorongkan': 'dorong',
'mendorongan': 'dorong',
'mendorongku': 'dorong',
'mendorongmu': 'dorong',
'pendorong': 'dorong',
'pendorongnya': 'dorong',
'pendorongan': 'dorong',
'pendorongmu': 'dorong',
'mendosir': 'dosir',
'berdosis': 'dosis',
'berdosisi': 'dosis',
'mengedot': 'dot',
'kedoyanan': 'doyan',
'pendramaan': 'drama',
'mengedrel': 'drel',
'pengedrelan': 'drel',
'mendribel': 'dribel',
'mendribelnya': 'dribel',
'mengedril': 'dril',
'mengedrop': 'drop',
'pengedropan': 'drop',
'sedua': 'dua',
'seduanya': 'dua',
'seduai': 'dua',
'kedua': 'dua',
'keduanya': 'dua',
'kedualah': 'dua',
'keduaan': 'dua',
'keduanyalah': 'dua',
'keduaku': 'dua',
'keduamu': 'dua',
'kedua-ku': 'dua',
'mendua': 'dua',
'menduanya': 'dua',
'menduakan': 'dua',
'menduakannya': 'dua',
'pendua': 'dua',
'perdua': 'dua',
'perduaan': 'dua',
'berdua': 'dua',
'berduanya': 'dua',
'berdualah': 'dua',
'berduakan': 'dua',
'berduaan': 'dua',
'dua-dua': 'dua',
'dua-duanya': 'dua',
'dua-duaan': 'dua',
'dua-duanyalah': 'dua',
'menduai': 'dua',
'seperdua': 'dua',
'penduaan': 'dua',
'berduaannya': 'dua',
'menyedua': 'dua',
'menyeduakan': 'dua',
'memperdua': 'dua',
'menyeduai': 'dua',
'berdua-dua': 'dua',
'berdua-duanya': 'dua',
'berdua-duaan': 'dua',
'memperduai': 'dua',
'dua-duanyanya': 'dua',
'memperduakan': 'dua',
'mengedub': 'dub',
'pengeduban': 'dub',
'mendubeskan': 'dubes',
'dubilah': 'dubila',
'mendublir': 'dublir',
'mendudu': 'dudu',
'mendudukan': 'dudu',
'mendudukannya': 'dudu',
'mendudui': 'dudu',
'menduduku': 'dudu',
'mendudu-dudu': 'dudu',
'penduduk': 'duduk',
'penduduknya': 'duduk',
'pendudukkan': 'duduk',
'penduduki': 'duduk',
'pendudukan': 'duduk',
'pendudukmu': 'duduk',
'terduduk': 'duduk',
'terduduki': 'duduk',
'kedudukan': 'duduk',
'kedudukannya': 'duduk',
'kedudukanku': 'duduk',
'kedudukanmu': 'duduk',
'menduduki': 'duduk',
'mendudukinya': 'duduk',
'pendudukannya': 'duduk',
'duduk-duduk': 'duduk',
'duduk-duduknya': 'duduk',
'duduk-dudukan': 'duduk',
'mendudukkan': 'duduk',
'mendudukkannya': 'duduk',
'sekedudukan': 'duduk',
'berkedudukan': 'duduk',
'mendudur': 'dudur',
'berduel': 'duel',
'berduet': 'duet',
'berduetnya': 'duet',
'dugaan': 'duga',
'dugaannya': 'duga',
'dugaanku': 'duga',
'penduga': 'duga',
'pendugaan': 'duga',
'menduga': 'duga',
'menduganya': 'duga',
'mendugalah': 'duga',
'mendugakan': 'duga',
'mendugaan': 'duga',
'terduga': 'duga',
'terduganya': 'duga',
'terduga-duga': 'duga',
'menduga-duga': 'duga',
'menduga-duganya': 'duga',
'mendugalkan': 'dugal',
'mendugang': 'dugang',
'mendugas': 'dugas',
'berduka': 'duka',
'berdukanya': 'duka',
'kedukaan': 'duka',
'kedukaannya': 'duka',
'mendukai': 'duka',
'mendukakan': 'duka',
'pedukuhan': 'dukuh',
'berdukun': 'dukun',
'perdukunan': 'dukun',
'perdukunannya': 'dukun',
'pendukunan': 'dukun',
'mendukunkan': 'dukun',
'dukungan': 'dukung',
'dukungannya': 'dukung',
'dukunganlah': 'dukung',
'dukunganan': 'dukung',
'dukunganku': 'dukung',
'dukunganmu': 'dukung',
'mendukung': 'dukung',
'mendukungnya': 'dukung',
'mendukunglah': 'dukung',
'mendukungi': 'dukung',
'mendukungan': 'dukung',
'mendukungku': 'dukung',
'mendukungmu': 'dukung',
'berdukung': 'dukung',
'pendukung': 'dukung',
'pendukungnya': 'dukung',
'pendukungkan': 'dukung',
'pendukungan': 'dukung',
'pendukungku': 'dukung',
'pendukungmu': 'dukung',
'pendukungannya': 'dukung',
'mendulag': 'dulag',
'pendulang': 'dulang',
'pendulangan': 'dulang',
'mendulang': 'dulang',
'dulang-dulang': 'dulang',
'dulang-dulangan': 'dulang',
'berduli': 'duli',
'mengedumkan': 'dum',
'mendungas': 'dungas',
'kedunguan': 'dungu',
'kedunguannya': 'dungu',
'kedunguanku': 'dungu',
'sedunia': 'dunia',
'mendunia': 'dunia',
'mendunianya': 'dunia',
'menduniakan': 'dunia',
'keduniaan': 'dunia',
'keduniaannya': 'dunia',
'keduniawian': 'duniawi',
'keduniawiannya': 'duniawi',
'mengedup': 'dup',
'pedupaan': 'dupa',
'mendupai': 'dupa',
'mendupak': 'dupak',
'berdurasi': 'durasi',
'berdurasikan': 'durasi',
'pendurhaka': 'durhaka',
'pendurhakaan': 'durhaka',
'berdurhaka': 'durhaka',
'mendurhaka': 'durhaka',
'mendurhakakan': 'durhaka',
'mendurhakai': 'durhaka',
'kedurjanaan': 'durjana',
'berduru': 'duru',
'berduru-duru': 'duru',
'mendusin': 'dusin',
'pedusunan': 'dusun',
'kedutaan': 'duta',
'kedutaannya': 'duta',
'berduyun-duyun': 'duyun',
'berduyun-duyunnya': 'duyun',
'kedwiartian': 'dwiarti',
'kedwibahasaan': 'dwibahasa',
'berdwifungsi': 'dwifungsi',
'mendwigandakan': 'dwiganda',
'dwimingguan': 'dwiminggu',
'kedwimukaan': 'dwimuka',
'dwiperanan': 'dwiperan',
'dieban': 'eban',
'mengeban': 'eban',
'ecek-ecek': 'ecek',
'ecek-eceknya': 'ecek',
'eceran': 'ecer',
'ecerannya': 'ecer',
'mengecer': 'ecer',
'mengecernya': 'ecer',
'mengecerkan': 'ecer',
'pengecer': 'ecer',
'pengecernya': 'ecer',
'pengeceran': 'ecer',
'keedanan': 'edan',
'edan-edanan': 'edan',
'edaran': 'edar',
'edarannya': 'edar',
'beredar': 'edar',
'beredarnya': 'edar',
'beredarlah': 'edar',
'beredarkan': 'edar',
'beredari': 'edar',
'beredaran': 'edar',
'mengedar': 'edar',
'mengedarnya': 'edar',
'mengedarkan': 'edar',
'mengedarkannya': 'edar',
'mengedari': 'edar',
'pengedar': 'edar',
'pengedarnya': 'edar',
'pengedaran': 'edar',
'peredaran': 'edar',
'peredarannya': 'edar',
'peredaranan': 'edar',
'mengedarinya': 'edar',
'mengedarian': 'edar',
'memperedarkan': 'edar',
'pengedit': 'edit',
'pengeditan': 'edit',
'mengedit': 'edit',
'mengeditnya': 'edit',
'mengeditkan': 'edit',
'pengeditannya': 'edit',
'keefektifan': 'efektif',
'keefektifannya': 'efektif',
'mengefektifkan': 'efektif',
'mengefisienkan': 'efisien',
'mengegah': 'egah',
'mengegatkan': 'egat',
'mengegol': 'egol',
'mengegolkan': 'gol',
'mengegos': 'egos',
'mengegosi': 'egos',
'mengegoskan': 'egos',
'keegosentrisan': 'egosentris',
'ejaan': 'eja',
'ejaannya': 'eja',
'mengeja': 'eja',
'mengejanya': 'eja',
'mengejakan': 'eja',
'mengejakannya': 'eja',
'pengejaan': 'eja',
'pengejaannya': 'eja',
'mengejan': 'kejan',
'mengejan-ejan': 'ejan',
'mengejawantah': 'ejawantah',
'mengejawantahkan': 'ejawantah',
'mengejawantahkannya': 'ejawantah',
'pengejawantahan': 'ejawantah',
'pengejawantahannya': 'ejawantah',
'ejekan': 'ejek',
'ejekannya': 'ejek',
'mengejek': 'ejek',
'mengejeknya': 'ejek',
'mengejeklah': 'ejek',
'mengejekku': 'ejek',
'mengejekmu': 'ejek',
'keekabahasaan': 'ekabahasa',
'terekeh-ekeh': 'ekeh',
'berekonomi': 'ekonomi',
'berekonomian': 'ekonomi',
'keekonomian': 'ekonomi',
'keekonomiannya': 'ekonomi',
'perekonomian': 'ekonomi',
'perekonomiannya': 'ekonomi',
'keekonomisan': 'ekonomis',
'keekonomisannya': 'ekonomis',
'berekor': 'ekor',
'mengekor': 'ekor',
'mengekornya': 'ekor',
'mengekori': 'ekor',
'pengekor': 'ekor',
'pengekornya': 'ekor',
'mengeksamen': 'eksamen',
'keeksentrikan': 'eksentrik',
'keeksentrikannya': 'eksentrik',
'mengeksklusifkan': 'eksklusif',
'mengeksklusifkannya': 'eksklusif',
'berekskursi': 'ekskursi',
'keeksotisan': 'eksotis',
'keeksotisannya': 'eksotis',
'berekspansi': 'ekspansi',
'mengeksploitasi': 'eksploitasi',
'mengeksploitasinya': 'eksploitasi',
'mengeksploitasikan': 'eksploitasi',
'pengeksploitasi': 'eksploitasi',
'pengeksploitasian': 'eksploitasi',
'mengeksplorasi': 'eksplorasi',
'mengeksplorasinya': 'eksplorasi',
'mengeksplorasikan': 'eksplorasi',
'mengeksplorasikannya': 'eksplorasi',
'pengekspor': 'ekspor',
'pengekspornya': 'ekspor',
'pengeksporan': 'ekspor',
'mengekspor': 'ekspor',
'mengekspornya': 'ekspor',
'mengeksporkan': 'ekspor',
'terekspos': 'ekspos',
'tereksposnya': 'ekspos',
'mengekspos': 'ekspos',
'mengeksposnya': 'ekspos',
'mengeksposmu': 'ekspos',
'pengeksposan': 'ekspos',
'mengekspresikan': 'ekspresi',
'mengekspresikannya': 'ekspresi',
'mengekstrak': 'ekstrak',
'mengekstraknya': 'ekstrak',
'mengekstraksi': 'ekstraksi',
'mengekstraksinya': 'ekstraksi',
'pengekstraksi': 'ekstraksi',
'keekstreman': 'ekstrem',
'mengelaborasi': 'elaborasi',
'mengelaborasinya': 'elaborasi',
'mengelaborasikan': 'elaborasi',
'mengelaborasikannya': 'elaborasi',
'mengelak': 'lak',
'mengelaknya': 'lak',
'mengelakkan': 'lak',
'mengelakkannya': 'lak',
'mengelaki': 'lak',
'mengelakan': 'lak',
'pengelakan': 'elak',
'terelakkan': 'elak',
'terelakkannya': 'elak',
'keelastikan': 'elastik',
'keelastisan': 'elastis',
'keelastisannya': 'elastis',
'keeleganan': 'elegan',
'keeleganannya': 'elegan',
'mengelektrifikasi': 'elektrifikasi',
'mengeliminasi': 'eliminasi',
'mengeliminasinya': 'eliminasi',
'mengelite': 'elite',
'seelok': 'elok',
'keelokan': 'elok',
'keelokannya': 'elok',
'memperelok': 'elok',
'mempereloknya': 'elok',
'seelok-eloknya': 'elok',
'mengelon': 'elon',
'mengeloni': 'kelon',
'mengelukan': 'elu',
'mengelukannya': 'elu',
'mengelu-elukan': 'elu',
'mengelu-elukannya': 'elu',
'elusan': 'elus',
'mengelus': 'elus',
'mengelusnya': 'elus',
'mengeluskan': 'elus',
'mengelus-elus': 'elus',
'mengelus-elusnya': 'elus',
'beremas': 'emas',
'keemasan': 'emas',
'keemasannya': 'emas',
'peremasan': 'emas',
'mengemat': 'emat',
'mengemban': 'emban',
'mengembannya': 'emban',
'mengembankan': 'emban',
'embaran': 'embar',
'pengembara': 'embara',
'pengembaraan': 'embara',
'mengembara': 'embara',
'mengembaranya': 'embara',
'mengembarai': 'embara',
'pengembaraannya': 'embara',
'pengembaraanku': 'embara',
'mengembargo': 'embargo',
'mengembat': 'embat',
'mengembatkan': 'embat',
'mengembik': 'embik',
'mengembol': 'kembol',
'embuh-embuhan': 'embuh',
'embusan': 'embus',
'embusannya': 'embus',
'berembus': 'embus',
'berembusnya': 'embus',
'pengembus': 'embus',
'mengembus': 'embus',
'mengembuskan': 'embus',
'mengembuskannya': 'embus',
'mengembut': 'embut',
'terembut-embut': 'embut',
'mengembut-embut': 'embut',
'beremigrasi': 'emigrasi',
'keemiratan': 'emirat',
'pengemis': 'emis',
'pengemisnya': 'emis',
'pengemisi': 'emis',
'pengemisan': 'emis',
'mengemis': 'emis',
'mengemisnya': 'emis',
'mengemislah': 'emis',
'mengemisi': 'emis',
'mengemohi': 'emoh',
'mengemol': 'emol',
'paemong': 'emong',
'mengemong': 'emong',
'keemosian': 'emosi',
'empangan': 'empang',
'terempang': 'empang',
'pengempang': 'empang',
'pengempangan': 'empang',
'mengempang': 'empang',
'terempap': 'empap',
'berempap': 'empap',
'mengempap': 'empap',
'mengempapkan': 'empap',
'mengempar': 'empar',
'mengemparkan': 'empar',
'empasan': 'empas',
'terempas': 'empas',
'mengempas': 'empas',
'mengempasnya': 'empas',
'mengempaskan': 'empas',
'mengempaskannya': 'empas',
'terempas-empas': 'empas',
'mengempas-empaskan': 'empas',
'perempat': 'empat',
'perempatnya': 'empat',
'perempatlah': 'empat',
'perempati': 'empat',
'perempatan': 'empat',
'berempat': 'empat',
'berempati': 'empat',
'perempatanan': 'empat',
'seperempat': 'empat',
'seperempatnya': 'empat',
'seperempatan': 'empat',
'memperempat': 'empat',
'empat-empat': 'empat',
'empat-empatnya': 'empat',
'berempat-empat': 'empat',
'keempat-empatnya': 'empat',
'mengempat puluh hari': 'empat',
'berempatilah': 'empati',
'empek-empek': 'empek',
'mengempenak': 'empenak',
'emperan': 'emper',
'empet-empetan': 'empet',
'mengempik': 'empik',
'mengemping': 'emping',
'memperemping': 'emping',
'mengempo': 'empo',
'mengempoh': 'empoh',
'keempohan': 'empoh',
'mengempohi': 'empoh',
'pengempohan': 'empoh',
'empok-empok': 'empok',
'emposan': 'empos',
'mengempos': 'empos',
'empot-empotan': 'empot',
'mengempu': 'empu',
'mengempukkan': 'empuk',
'mengempul': 'empul',
'mengempulkan': 'empul',
'mengemut': 'kemut',
'mengemutnya': 'kemut',
'mengemuti': 'kemut',
'terenak': 'enak',
'keenakan': 'enak',
'keenakannya': 'enak',
'keenakanlah': 'enak',
'enak-enak': 'enak',
'enak-enaknya': 'enak',
'enak-enakkan': 'enak',
'enak-enakan': 'enak',
'seenaknya': 'enak',
'memperenak': 'enak',
'mengenakkan': 'enak',
'mengenakkannya': 'enak',
'berenak-enak': 'enak',
'berenam': 'enam',
'mengenap': 'enap',
'mengenapkan': 'enap',
'mengenapi': 'enap',
'mengenap-enapkan': 'enap',
'mengenaskan': 'ngenas',
'mengenaskannya': 'ngenas',
'encal-encal': 'encal',
'mengencang': 'encang',
'mengencangnya': 'encang',
'mengencangkan': 'kencang',
'mengencangkannya': 'kencang',
'berencel-encel': 'encel',
'enceran': 'encer',
'pengencer': 'encer',
'pengenceran': 'encer',
'pengencerannya': 'encer',
'mengencerkan': 'encer',
'mengencerkannya': 'encer',
'mengendal': 'endal',
'mengendalkan': 'endal',
'mengendali': 'endal',
'endapan': 'endap',
'endapannya': 'endap',
'mengendap': 'endap',
'mengendapnya': 'endap',
'mengendapkan': 'endap',
'mengendapkannya': 'endap',
'terendapkan': 'endap',
'endap-endap': 'endap',
'pengendapan': 'endap',
'pengendapannya': 'endap',
'mengendap-endap': 'endap',
'endonan': 'endon',
'mengendon': 'endon',
'mengendonkan': 'endon',
'mengendong': 'kendong',
'mengendongnya': 'kendong',
'mengendus': 'endus',
'mengendusnya': 'endus',
'mengenduskan': 'endus',
'mengendusku': 'endus',
'endut-endut': 'endut',
'endut-endutan': 'endut',
'mengenes': 'enes',
'mengeneskan': 'enes',
'engah-engah': 'engah',
'terperengah': 'engah',
'terengah-engah': 'engah',
'keengganan': 'enggan',
'keengganannya': 'enggan',
'mengenggankan': 'enggan',
'enggan-enggan': 'enggan',
'berenggan-enggan': 'enggan',
'mengengget': 'engget',
'berenggil': 'enggil',
'enggokan': 'enggok',
'engkah-engkah': 'engkah',
'mengengkang': 'engkang',
'berengkau': 'engkau',
'mengenjak': 'enjak',
'mengenjak-enjak': 'enjak',
'mengenjal': 'enjal',
'mengenjut': 'enjut',
'mengenjutkan': 'enjut',
'mengenkripsi': 'enkripsi',
'mengenkripsinya': 'enkripsi',
'entah-berentah': 'entah',
'pengentak': 'entak',
'mengentak': 'entak',
'mengentakkan': 'entak',
'mengentak-entak': 'entak',
'mengentak-entakkan': 'entak',
'terentas': 'entas',
'terentaskan': 'entas',
'terentaskannya': 'entas',
'mengentas': 'entas',
'mengentaskan': 'entas',
'mengentaskannya': 'entas',
'mengentasi': 'entas',
'mengentasan': 'entas',
'pengentasan': 'entas',
'pengentasannya': 'entas',
'mengenten': 'enten',
'enten-enten': 'enten',
'mengentengkan': 'enteng',
'mengentit': 'entit',
'mengentot': 'entot',
'mengenyahkan': 'enyah',
'mengenyahkannya': 'enyah',
'mengenyak': 'enyak',
'terperenyak': 'perenyak',
'mengenyakkan': 'enyak',
'pengepak': 'pak',
'pengepakkan': 'pak',
'pengepakan': 'pak',
'pengepakannya': 'pak',
'mengeram': 'eram',
'mengeramkan': 'eram',
'mengerami': 'eram',
'pengeram': 'eram',
'pengeraman': 'eram',
'mengeraminya': 'eram',
'pengeramannya': 'eram',
'erangan': 'erang',
'erangannya': 'erang',
'mengerang': 'erang',
'mengeranglah': 'erang',
'erang-erot': 'erang',
'erat-erat': 'erat',
'mempererat': 'erat',
'mempereratnya': 'erat',
'mengeratkan': 'erat',
'mengeratkannya': 'erat',
'pengereh': 'ereh',
'mengereh': 'ereh',
'berereksi': 'ereksi',
'terereng': 'ereng',
'mengereng': 'ereng',
'ereng-ereng': 'ereng',
'eretan': 'eret',
'mengeret': 'eret',
'pengeret': 'eret',
'pengeretan': 'eret',
'mengerik': 'kerik',
'mengeriknya': 'kerik',
'mengerikan': 'ngeri',
'erong-erong': 'erong',
'erotan': 'erot',
'bererot': 'rerot',
'bererotan': 'erot',
'mengerotkan': 'erot',
'mengerti': 'erti',
'mengertinya': 'erti',
'mengertilah': 'erti',
'mengertikan': 'erti',
'mengertii': 'erti',
'mengertian': 'erti',
'pengertian': 'erti',
'pengertiannya': 'erti',
'pengertianku': 'erti',
'keesaan': 'esa',
'mengesakan': 'kesak',
'beresa-esaan': 'esa',
'teresak': 'esak',
'mengesak': 'kesak',
'teresak-esak': 'esak',
'beresok': 'esok',
'keesokan': 'esok',
'keesokannya': 'esok',
'mengesokkan': 'esok',
'mengesot-esot': 'esot',
'mengetsa': 'etsa',
'pengetsaan': 'etsa',
'berevakuasi': 'evakuasi',
'mengevakuasi': 'evakuasi',
'mengevakuasinya': 'evakuasi',
'mengevakuasikan': 'evakuasi',
'mengevaluasi': 'evaluasi',
'mengevaluasinya': 'evaluasi',
'mengevaluasikan': 'evaluasi',
'keevolusian': 'evolusi',
'mengeyel': 'eyel',
'memfaalkan': 'faal',
'memfadihatkan': 'fadihat',
'berfaedah': 'faedah',
'berfaedahnya': 'faedah',
'kefakiran': 'fakir',
'kefanaan': 'fana',
'memfanakan': 'fana',
'kefanatikan': 'fanatik',
'kefanatikannya': 'fanatik',
'memfanatiki': 'fanatik',
'berfantasi': 'fantasi',
'berfantasinya': 'fantasi',
'berfantasilah': 'fantasi',
'memfantasikan': 'fantasi',
'kefarmasian': 'farmasi',
'memfasakh': 'fasakh',
'kefasihan': 'fasih',
'kefasihannya': 'fasih',
'memperfasih': 'fasih',
'memfasihkan': 'fasih',
'kefasikan': 'fasik',
'memfasilitasi': 'fasilitas',
'memfasilitasinya': 'fasilitas',
'memfasilitasikan': 'fasilitas',
'memfasilitasiku': 'fasilitas',
'berfatwa': 'fatwa',
'memfatwakan': 'fatwa',
'kefemininan': 'feminin',
'kefemininannya': 'feminin',
'memfestivalkan': 'festival',
'memfiat': 'fiat',
'perfilman': 'film',
'perfilmannya': 'film',
'memfilmkan': 'film',
'memfilmkannya': 'film',
'memfilter': 'filter',
'memfilternya': 'filter',
'berfirman': 'firman',
'difirmankan': 'firman',
'memfitnah': 'fitnah',
'memfitnahnya': 'fitnah',
'memfitnahkan': 'fitnah',
'berfitrah': 'fitrah',
'memfitrahkan': 'fitrah',
'berfluktuasi': 'fluktuasi',
'berfluktuasinya': 'fluktuasi',
'terfokus': 'fokus',
'terfokusnya': 'fokus',
'terfokuskan': 'fokus',
'memfokus': 'fokus',
'memfokuskan': 'fokus',
'memfokuskannya': 'fokus',
'berfokus': 'fokus',
'berfokuslah': 'fokus',
'berfokuskan': 'fokus',
'pemfokusan': 'fokus',
'memformulasikan': 'formulasi',
'memformulasikannya': 'formulasi',
'memforsir': 'forsir',
'memforsirnya': 'forsir',
'memfosil': 'fosil',
'pemfosilan': 'fosil',
'berfoto': 'foto',
'berfotonya': 'foto',
'berfotolah': 'foto',
'berfotokan': 'foto',
'memfotokopi': 'fotokopi',
'memfotokopinya': 'fotokopi',
'berfoya-foya': 'foya',
'kefrustrasian': 'frustrasi',
'berfusi': 'fusi',
'memfusikan': 'fusi',
'menggaba-gabai': 'gaba-gaba',
'menggabai': 'gabai',
'menggabaikan': 'gabai',
'gabai-gabai': 'gabai',
'menggabak': 'gabak',
'tergabas': 'gabas',
'menggabas': 'gabas',
'menggabrukkan': 'gabruk',
'gabungan': 'gabung',
'gabungannya': 'gabung',
'segabung': 'gabung',
'bergabung': 'gabung',
'bergabungnya': 'gabung',
'bergabunglah': 'gabung',
'bergabungkan': 'gabung',
'bergabungan': 'gabung',
'tergabung': 'gabung',
'tergabungnya': 'gabung',
'tergabungan': 'gabung',
'menggabung': 'gabung',
'menggabungnya': 'gabung',
'menggabungkan': 'gabung',
'menggabungkannya': 'gabung',
'menggabungan': 'gabung',
'pergabungan': 'gabung',
'penggabungan': 'gabung',
'penggabungannya': 'gabung',
'ketergabungan': 'gabung',
'ketergabungannya': 'gabung',
'menggabungkankan': 'gabung',
'penggabus': 'gabus',
'menggabus': 'gabus',
'gacoan': 'gaco',
'gacoannya': 'gaco',
'menggacok': 'gacok',
'penggada': 'gada',
'penggadaan': 'gada',
'menggada': 'gada',
'menggadakan': 'gada',
'menggadakannya': 'gada',
'bergadang': 'gadang',
'menggadang': 'gadang',
'menggadangkan': 'gadang',
'bergading': 'gading',
'menggading': 'gading',
'menggadis': 'gadis',
'kegadisan': 'gadis',
'kegadisannya': 'gadis',
'kegadis-gadisan': 'gadis',
'menggado': 'gado',
'bergaduk': 'gaduk',
'menggaduk': 'gaduk',
'menggaduki': 'gaduk',
'menggaet': 'gaet',
'menggaetnya': 'gaet',
'menggaetkan': 'gaet',
'menggaetku': 'gaet',
'kegagahan': 'gagah',
'kegagahannya': 'gagah',
'menggagah': 'gagah',
'menggagahi': 'gagah',
'menggagahinya': 'gagah',
'menggagahkan': 'gagah',
'bergagah-gagahan': 'gagah',
'menggagai': 'gagai',
'penggagal': 'gagal',
'penggagalan': 'gagal',
'kegagalan': 'gagal',
'kegagalannya': 'gagal',
'kegagalanlah': 'gagal',
'kegagalanan': 'gagal',
'kegagalanku': 'gagal',
'kegagalanmu': 'gagal',
'menggagalkan': 'gagal',
'menggagalkannya': 'gagal',
'menggagap': 'gagap',
'menggagapnya': 'gagap',
'tergagap-gagap': 'gagap',
'bergagap-gagap': 'gagap',
'gagasan': 'gagas',
'gagasannya': 'gagas',
'gagasanmu': 'gagas',
'menggagas': 'gagas',
'menggagasnya': 'gagas',
'menggagaskan': 'gagas',
'penggagas': 'gagas',
'penggagasnya': 'gagas',
'penggagasan': 'gagas',
'tergagau': 'gagau',
'menggagau': 'gagau',
'bergagau-gagau': 'gagau',
'tergagau-gagau': 'gagau',
'tergaguk-gaguk': 'gaguk',
'menggaham': 'gaham',
'menggahar': 'gahar',
'menggaib': 'gaib',
'kegaiban': 'gaib',
'gail-gail': 'gail',
'bergairah': 'gairah',
'bergairahnya': 'gairah',
'bergairahlah': 'gairah',
'kegairahan': 'gairah',
'kegairahannya': 'gairah',
'menggairahkan': 'gairah',
'menggairahkannya': 'gairah',
'gaitan': 'gait',
'menggait': 'gait',
'penggait': 'gait',
'menggajah': 'gajah',
'gajah-gajahan': 'gajah',
'gajian': 'gaji',
'gajiannya': 'gaji',
'menggaji': 'gaji',
'menggajinya': 'gaji',
'menggajiku': 'gaji',
'penggajian': 'gaji',
'penggajiannya': 'gaji',
'bergajul': 'gajul',
'bergala': 'gala',
'gala-gala': 'gala',
'bergalah': 'galah',
'sepenggalah': 'galah',
'menggalahkan': 'galah',
'penggalak': 'galak',
'penggalakkan': 'galak',
'penggalakan': 'galak',
'kegalakan': 'galak',
'kegalakannya': 'galak',
'menggalak': 'galak',
'menggalakkan': 'galak',
'menggalakkannya': 'galak',
'menggalakan': 'galak',
'galangan': 'galang',
'galangannya': 'galang',
'tergalang': 'galang',
'bergalang': 'galang',
'bergalangan': 'galang',
'menggalang': 'galang',
'menggalangnya': 'galang',
'menggalangkan': 'galang',
'menggalangi': 'galang',
'menggalangan': 'galang',
'penggalang': 'galang',
'penggalangan': 'galang',
'penggalangannya': 'galang',
'penggalas': 'galas',
'menggalas': 'galas',
'penggalasan': 'galas',
'bergalat': 'galat',
'bergalau': 'galau',
'kegalauan': 'galau',
'kegalauannya': 'galau',
'galengan': 'galeng',
'galian': 'gali',
'galiannya': 'gali',
'galiani': 'gali',
'penggali': 'gali',
'penggalinya': 'gali',
'penggalian': 'gali',
'menggali': 'gali',
'menggalinya': 'gali',
'menggalikan': 'gali',
'penggaliannya': 'gali',
'gali-galian': 'gali',
'menggali-gali': 'gali',
'kegaliban': 'galib',
'menggalibkan': 'galib',
'menggalurkan': 'galur',
'bergalur-galur': 'galur',
'menggalur-galur': 'galur',
'tergamak': 'gamak',
'gamak-gamak': 'gamak',
'menggamak-gamak': 'gamak',
'tergamang': 'gamang',
'penggamang': 'gamang',
'bergamat': 'gamat',
'menggamat': 'gamat',
'kegamblangan': 'gamblang',
'bergambuh': 'gambuh',
'menggamik': 'gamik',
'gamitan': 'gamit',
'bergamit': 'gamit',
'menggamit': 'gamit',
'bergamitan': 'gamit',
'gamit-gamitan': 'gamit',
'menggamit-gamitkan': 'gamit',
'gampangan': 'gampang',
'gampangannya': 'gampang',
'menggampangkan': 'gampang',
'gampang-gampangan': 'gampang',
'tergampar': 'gampar',
'menggampar': 'gampar',
'menggamparku': 'gampar',
'ganal-ganal': 'ganal',
'keganasan': 'ganas',
'keganasannya': 'ganas',
'mengganas': 'ganas',
'mengganasnya': 'ganas',
'pengganas': 'ganas',
'gancaran': 'gancar',
'menggancu': 'gancu',
'gandalan': 'gandal',
'penggandal': 'gandal',
'gandaran': 'gandar',
'penggandar': 'gandar',
'menggandar': 'gandar',
'gandengan': 'gandeng',
'gandengannya': 'gandeng',
'bergandeng': 'gandeng',
'bergandengnya': 'gandeng',
'bergandengan': 'gandeng',
'menggandeng': 'gandeng',
'menggandengnya': 'gandeng',
'menggandengkan': 'gandeng',
'menggandengkannya': 'gandeng',
'menggandengan': 'gandeng',
'pergandengan': 'gandeng',
'penggandengan': 'gandeng',
'mempergandengkan': 'gandeng',
'kegandrungan': 'gandrung',
'kegandrungannya': 'gandrung',
'menggandrungi': 'gandrung',
'menggandrunginya': 'gandrung',
'menggandrungiku': 'gandrung',
'menggandrungkan': 'gandrung',
'berganduh': 'ganduh',
'memperganduhkan': 'ganduh',
'memperganduh-ganduhkan': 'ganduh',
'gandulan': 'gandul',
'menggandul': 'gandul',
'mengganduli': 'gandul',
'bergandung': 'gandung',
'menggandung': 'gandung',
'berganggang': 'ganggang',
'mengganggang': 'ganggang',
'mengganggangkan': 'ganggang',
'mengganggu gugat': 'ganggu gugat',
'gangguan': 'ganggu',
'gangguannya': 'ganggu',
'gangguanlah': 'ganggu',
'terganggu': 'ganggu',
'terganggunya': 'ganggu',
'terganggulah': 'ganggu',
'terganggukan': 'ganggu',
'terganggui': 'ganggu',
'mengganggu': 'ganggu',
'mengganggunya': 'ganggu',
'mengganggulah': 'ganggu',
'mengganggui': 'ganggu',
'menggangguan': 'ganggu',
'menggangguku': 'ganggu',
'mengganggumu': 'ganggu',
'pengganggu': 'ganggu',
'pengganggunya': 'ganggu',
'penggangguan': 'ganggu',
'mengganggut': 'ganggut',
'pegangsaan': 'gangsa',
'menggangsi': 'gangsi',
'gangsiran': 'gangsir',
'menggangsir': 'gangsir',
'penggangsir': 'gangsir',
'penggangsiran': 'gangsir',
'ganjalan': 'ganjal',
'ganjalannya': 'ganjal',
'berganjal': 'ganjal',
'terganjal': 'ganjal',
'terganjalnya': 'ganjal',
'pengganjal': 'ganjal',
'pengganjalnya': 'ganjal',
'pengganjalan': 'ganjal',
'mengganjal': 'ganjal',
'mengganjalnya': 'ganjal',
'mengganjali': 'ganjal',
'ganjal-mengganjal': 'ganjal',
'ganjaran': 'ganjar',
'ganjarannya': 'ganjar',
'ganjaranmu': 'ganjar',
'ganjaran-mu': 'ganjar',
'mengganjar': 'ganjar',
'mengganjarnya': 'ganjar',
'mengganjari': 'ganjar',
'mengganjarkan': 'ganjar',
'mengganjil': 'ganjil',
'mengganjilkan': 'ganjil',
'keganjilan': 'ganjil',
'keganjilannya': 'ganjil',
'berganjur': 'ganjur',
'mengganjur': 'ganjur',
'mengganjuri': 'ganjur',
'berganjur-ganjur': 'ganjur',
'segantang': 'gantang',
'menggantang': 'gantang',
'gantelan': 'gantel',
'menggantelkan': 'gantel',
'menggantih': 'gantih',
'menggantol': 'gantol',
'mengganyah': 'ganyah',
'mengganyang': 'ganyang',
'mengganyangnya': 'ganyang',
'menggaok': 'gaok',
'kegapahan': 'gapah',
'tergapai': 'gapai',
'menggapai': 'gapai',
'menggapainya': 'gapai',
'menggapaikan': 'gapai',
'bergapaian': 'gapai',
'tergapai-gapai': 'gapai',
'menggapai-gapai': 'gapai',
'menggapai-gapaikan': 'gapai',
'menggapil': 'gapil',
'menggapit': 'gapit',
'gaplokan': 'gaplok',
'menggaplok': 'gaplok',
'menggaploki': 'gaplok',
'bergarah': 'garah',
'menggarah': 'garah',
'menggarahkan': 'garah',
'garah-garah': 'garah',
'bergarah-garah': 'garah',
'mempergarahkan': 'garah',
'bergaram': 'garam',
'menggaram': 'garam',
'menggarami': 'garam',
'pegaraman': 'garam',
'menggaraminya': 'garam',
'penggaraman': 'garam',
'menggaramkan': 'garam',
'garangan': 'garang',
'menggarang': 'garang',
'menggarangi': 'garang',
'penggarang': 'garang',
'kegarangan': 'garang',
'kegarangannya': 'garang',
'menggarangkan': 'garang',
'bergaransi': 'garansi',
'bergaransinya': 'garansi',
'garapan': 'garap',
'garapannya': 'garap',
'tergarap': 'garap',
'tergarapnya': 'garap',
'menggarap': 'garap',
'menggarapnya': 'garap',
'menggarapkan': 'garap',
'penggarap': 'garap',
'penggarapnya': 'garap',
'penggarapan': 'garap',
'penggarapannya': 'garap',
'bergarau': 'garau',
'menggari': 'gari',
'menggarisbawahi': 'garis bawah',
'menggarisbawahinya': 'garis bawah',
'segaris': 'garis',
'bergaris': 'garis',
'menggaris': 'garis',
'menggariskan': 'garis',
'menggarisi': 'garis',
'penggaris': 'garis',
'penggarisan': 'garis',
'garitan': 'garit',
'menggarit': 'garit',
'menggaritkan': 'garit',
'penggarong': 'garong',
'penggarongan': 'garong',
'menggarong': 'garong',
'penggaru': 'garu',
'penggarukan': 'garu',
'penggaruan': 'garu',
'menggaru': 'garu',
'garukan': 'garuk',
'garukannya': 'garuk',
'tergaruk': 'garuk',
'menggaruk': 'garuk',
'menggaruknya': 'garuk',
'menggarukkan': 'garuk',
'menggaruki': 'garuk',
'penggaruk': 'garuk',
'bergaruk-garuk': 'garuk',
'menggaruk-garuk': 'garuk',
'menggaruk-garukkan': 'garuk',
'menggaruk-garukan': 'garuk',
'menggarung': 'garung',
'menggarut': 'garut',
'menggasab': 'gasab',
'gasakan': 'gasak',
'menggasak': 'gasak',
'menggasaknya': 'gasak',
'menggasakan': 'gasak',
'menggasakkan': 'gasak',
'gasak-gasakan': 'gasak',
'bergasing': 'gasing',
'kegatalan': 'gatal',
'menggatalkan': 'gatal',
'menggatra': 'gatra',
'bergaun': 'gaun',
'pegawai': 'gawai',
'pegawainya': 'gawai',
'pegawaian': 'gawai',
'pegawaiku': 'gawai',
'pegawaimu': 'gawai',
'gawangan': 'gawang',
'gawar-gawar': 'gawar',
'gawatan': 'gawat',
'kegawatan': 'gawat',
'kegawatannya': 'gawat',
'menggawat': 'gawat',
'menggawatkan': 'gawat',
'bergayuh': 'gayuh',
'menggayuh': 'gayuh',
'menggayuk': 'gayuk',
'menggayun': 'gayun',
'bergayung': 'gayung',
'menggayung': 'gayung',
'menggebah': 'gebah',
'gebaran': 'gebar',
'menggeblak': 'geblak',
'geblokan': 'geblok',
'segeblok': 'geblok',
'menggebok': 'gebok',
'menggebos': 'gebos',
'menggebosi': 'gebos',
'menggebot': 'gebot',
'gebrakan': 'gebrak',
'gebrakannya': 'gebrak',
'menggebrak': 'gebrak',
'menggebu': 'gebu',
'menggebunya': 'gebu',
'menggebu-gebu': 'gebu',
'menggebu-gebunya': 'gebu',
'gebukan': 'gebuk',
'menggebuk': 'gebuk',
'menggebuki': 'gebuk',
'menggebukinya': 'gebuk',
'menggebyah-uyah': 'gebyah-uyah',
'gebyar-gebyar': 'gebyar',
'gebyuran': 'gebyur',
'menggebyur': 'gebyur',
'menggecarkan': 'gecar',
'menggecek': 'gecek',
'gedean': 'gede',
'penggede': 'gede',
'gedokan': 'gedok',
'gedongan': 'gedong',
'gedoran': 'gedor',
'tergedor': 'gedor',
'penggedor': 'gedor',
'penggedornya': 'gedor',
'penggedoran': 'gedor',
'menggedor': 'gedor',
'menggedornya': 'gedor',
'bergeduyut': 'geduyut',
'tergegap-gegap': 'gegap',
'tergegau': 'gegau',
'kegegeran': 'geger',
'menggeger': 'geger',
'menggegerkan': 'geger',
'menggejala': 'gejala',
'menggejalanya': 'gejala',
'menggejos': 'gejos',
'menggejoskan': 'gejos',
'menggejuju': 'gejuju',
'menggelabur': 'gelabur',
'menggeladrah': 'geladrah',
'gelagapan': 'gelagap',
'bergelagar': 'gelagar',
'bergelagaran': 'gelagar',
'tergelak': 'gelak',
'menggelakkan': 'gelak',
'tergelak-gelak': 'gelak',
'menggelalar': 'gelalar',
'menggelamai': 'gelamai',
'bergelambir': 'gelambir',
'bergelambirku': 'gelambir',
'gelandangan': 'gelandang',
'menggelandang': 'gelandang',
'menggelandangnya': 'gelandang',
'menggelandangan': 'gelandang',
'bergelandangan': 'gelandang',
'menggelandoti': 'gelandot',
'pergelangan': 'gelang',
'pergelangannya': 'gelang',
'pergelanganan': 'gelang',
'gelang-gelang': 'gelang',
'tergelang-gelang': 'gelang',
'bergelang-gelang': 'gelang',
'bergelanggang': 'gelanggang',
'menggelanggang': 'gelanggang',
'tergelangsar': 'gelangsar',
'menggelangsar': 'gelangsar',
'menggelantang': 'gelantang',
'menggelanting': 'gelanting',
'bergelantung': 'gelantung',
'bergelantungan': 'gelantung',
'menggelantung': 'gelantung',
'menggelantungkan': 'gelantung',
'menggelap': 'gelap',
'menggelapnya': 'gelap',
'menggelapkan': 'gelap',
'menggelapkannya': 'gelap',
'menggelapan': 'gelap',
'kegelapan': 'gelap',
'kegelapannya': 'gelap',
'penggelapan': 'gelap',
'penggelapannya': 'gelap',
'penggelapanlah': 'gelap',
'penggelapanan': 'gelap',
'gelap-gelapan': 'gelap',
'bergelap-gelap': 'gelap',
'bergelap-gelapan': 'gelap',
'kegelap-gelapan': 'gelap',
'gelasan': 'gelas',
'menggelas': 'gelas',
'bergelas-gelasan': 'gelas',
'menggelasir': 'gelasir',
'menggelatak': 'gelatak',
'menggelatuk': 'gelatuk',
'bergelayangan': 'gelayangan',
'gelayaran': 'gelayar',
'bergelayut': 'gelayut',
'bergelayutan': 'gelayut',
'tergelebar': 'gelebar',
'menggeleber': 'geleber',
'bergeleberan': 'geleber',
'tergelecik': 'gelecik',
'menggelecik': 'gelecik',
'menggeledah': 'geledah',
'menggeledahnya': 'geledah',
'menggeledahkan': 'geledah',
'menggeledahi': 'geledah',
'menggeledahan': 'geledah',
'menggeledahku': 'geledah',
'penggeledahan': 'geledah',
'penggeledahannya': 'geledah',
'menggeledang': 'geledang',
'menggeledek': 'geledek',
'menggeleding': 'geleding',
'menggeledur': 'geledur',
'bergelegak': 'gelegak',
'menggelegak': 'gelegak',
'menggelegakkan': 'gelegak',
'bergelegar': 'gelegar',
'menggelegar': 'gelegar',
'menggelegarnya': 'gelegar',
'menggelegarkan': 'gelegar',
'menggelek': 'gelek',
'menggelekkan': 'gelek',
'menggelekak': 'gelekak',
'menggelekek': 'gelekek',
'bergelembung': 'gelembung',
'menggelembung': 'gelembung',
'menggelembungnya': 'gelembung',
'menggelembungkan': 'gelembung',
'menggelembungan': 'gelembung',
'gelembung-gelembungan': 'gelembung',
'menggelembur': 'gelembur',
'bergelemprang': 'gelemprang',
'tergelenang': 'gelenang',
'menggelendong': 'gelendong',
'bergelendot': 'gelendot',
'menggelendot': 'gelendot',
'bergelendotan': 'gelendot',
'bergeleng': 'geleng',
'menggeleng': 'geleng',
'menggelengkan': 'geleng',
'bergeleng-geleng': 'geleng',
'tergeleng-geleng': 'geleng',
'menggeleng-gelengkan': 'geleng',
'menggelenting': 'gelenting',
'menggelenyar': 'gelenyar',
'menggelepai': 'gelepai',
'menggelepar': 'gelepar',
'bergeleparan': 'gelepar',
'menggelepar-gelepar': 'gelepar',
'menggelepar-geleparkan': 'gelepar',
'menggelepek': 'gelepek',
'menggelepur': 'gelepur',
'menggeleser': 'geleser',
'menggeleserkan': 'geleser',
'menggelesot': 'gelesot',
'tergeletak': 'geletak',
'tergeletaknya': 'geletak',
'menggeletak': 'geletak',
'menggeletakkan': 'geletak',
'menggeletakkannya': 'geletak',
'menggeletakan': 'geletak',
'menggeletar': 'geletar',
'menggeletarkan': 'geletar',
'menggeletik': 'geletik',
'menggeletis': 'geletis',
'gemeletuk': 'geletuk',
'menggeletuk': 'geletuk',
'kegelian': 'geli',
'kegeliannya': 'geli',
'penggeli': 'geli',
'menggeli': 'geli',
'menggelikan': 'geli',
'menggelikannya': 'geli',
'geli-geli': 'geli',
'menggeliang': 'geliang',
'geliang-geliut': 'geliang',
'menggeliang-geliutkan': 'geliang',
'tergeliat': 'geliat',
'menggeliat': 'geliat',
'menggeliatnya': 'geliat',
'menggeliatkan': 'geliat',
'geliat-geliut': 'geliat',
'menggelibir': 'gelibir',
'tergelicik': 'gelicik',
'menggelicikkan': 'gelicik',
'menggeligi': 'geligi',
'menggeligis': 'geligis',
'menggeligit': 'geligit',
'bergelimang': 'gelimang',
'bergelimangnya': 'gelimang',
'bergelimangan': 'gelimang',
'menggelimangi': 'gelimang',
'menggelimantang': 'gelimantang',
'gelimbiran': 'gelimbir',
'bergelimun': 'gelimun',
'menggelimuni': 'gelimun',
'tergelincir': 'gelincir',
'tergelincirnya': 'gelincir',
'tergelinciri': 'gelincir',
'menggelincir': 'gelincir',
'menggelincirkan': 'gelincir',
'tergelincuh': 'gelincuh',
'gelindingan': 'gelinding',
'menggelinding': 'gelinding',
'menggelindingnya': 'gelinding',
'menggelindingkan': 'gelinding',
'menggelindingkannya': 'gelinding',
'bergelindingan': 'gelinding',
'menggelinding-gelinding': 'gelinding',
'bergelingsir': 'gelingsir',
'tergelingsir': 'gelingsir',
'menggelingsir': 'gelingsir',
'menggelinjang': 'gelinjang',
'tergelintang': 'gelintang',
'menggelintar': 'gelintar',
'bergelintin': 'gelintin',
'menggelinting': 'gelinting',
'gelintiran': 'gelintir',
'segelintir': 'gelintir',
'segelintirnya': 'gelintir',
'segelintiran': 'gelintir',
'kegelisahan': 'gelisah',
'kegelisahannya': 'gelisah',
'kegelisahanku': 'gelisah',
'menggelisahi': 'gelisah',
'menggelisahkan': 'gelisah',
'kegelitaan': 'gelita',
'menggelitar': 'gelitar',
'gelitikan': 'gelitik',
'tergelitik': 'gelitik',
'tergelitiklah': 'gelitik',
'menggelitik': 'gelitik',
'menggelitiknya': 'gelitik',
'menggelitikkan': 'gelitik',
'menggelitiki': 'gelitik',
'menggelitikku': 'gelitik',
'menggelobok': 'gelobok',
'menggelodar': 'gelodar',
'menggelogok': 'gelogok',
'tergelohok': 'gelohok',
'menggelompar': 'gelompar',
'gelondongan': 'gelondong',
'gelondongannya': 'gelondong',
'bergelonggong': 'gelonggong',
'menggelongsor': 'gelongsor',
'menggelontor': 'gelontor',
'menggelontornya': 'gelontor',
'menggelontorkan': 'gelontor',
'menggelontorkannya': 'gelontor',
'menggelontori': 'gelontor',
'menggelontoran': 'gelontor',
'penggelontoran': 'gelontor',
'penggelontorannya': 'gelontor',
'menggelopak': 'gelopak',
'menggelosang': 'gelosang',
'menggeloso': 'geloso',
'menggelosok': 'gelosok',
'menggelotak': 'gelotak',
'bergelugut': 'gelugut',
'menggelugut': 'gelugut',
'menggelulur': 'gelulur',
'tergeluncur': 'geluncur',
'menggelundung': 'gelundung',
'bergelundungan': 'gelundung',
'menggelundungkan': 'gelundung',
'menggelup': 'gelup',
'menggelupur': 'gelupur',
'menggemak': 'gemak',
'menggemak-gemak': 'gemak',
'segemal': 'gemal',
'menggemal': 'gemal',
'bergemal-gemal': 'gemal',
'penggemang': 'gemang',
'tergemap': 'gemap',
'bergemar': 'gemar',
'penggemar': 'gemar',
'penggemarnya': 'gemar',
'penggemarlah': 'gemar',
'penggemarku': 'gemar',
'penggemarmu': 'gemar',
'kegemaran': 'gemar',
'kegemarannya': 'gemar',
'kegemaranku': 'gemar',
'menggemari': 'gemar',
'menggemarinya': 'gemar',
'menggemarii': 'gemar',
'menggemarkan': 'gemar',
'kegemasan': 'gemas',
'menggemaskan': 'gemas',
'menggemaskannya': 'gemas',
'penggembala': 'gembala',
'penggembalanya': 'gembala',
'penggembalaan': 'gembala',
'penggembalaannya': 'gembala',
'menggembalakan': 'gembala',
'menggembalakannya': 'gembala',
'bergembar-gembor': 'gembar-gembor',
'penggembar-gemboran': 'gembar-gembor',
'menggembar-gemborkan': 'gembar-gembor',
'menggembar-gemborkannya': 'gembar-gembor',
'tergembleng': 'gembleng',
'bergembleng': 'gembleng',
'penggemblengan': 'gembleng',
'bergembok': 'gembok',
'tergembok': 'gembok',
'menggembok': 'gembok',
'menggemboknya': 'gembok',
'menggembokkannya': 'gembok',
'menggembokan': 'gembok',
'penggembok': 'gembok',
'penggembokan': 'gembok',
'menggembol': 'gembol',
'menggembos': 'gembos',
'menggemboskan': 'gembos',
'menggembosi': 'gembos',
'penggembosan': 'gembos',
'bergembung': 'gembung',
'penggembungan': 'gembung',
'menggembungkan': 'gembung',
'menggemburkan': 'gembur',
'gembusan': 'gembus',
'menggembut': 'gembut',
'bergembut-gembut': 'gembut',
'menggemeretakkan': 'gemeretak',
'menggemeretakkannya': 'gemeretak',
'gemerlapan': 'gemerlap',
'gemerlapannya': 'gemerlap',
'menggemik': 'gemik',
'kegemilangan': 'gemilang',
'kegemilangannya': 'gemilang',
'tergeming': 'geming',
'bergeming': 'geming',
'bergemingnya': 'geming',
'bergempa': 'gempa',
'menggempakan': 'gempa',
'kegemparan': 'gempar',
'kegemparannya': 'gempar',
'menggemparkan': 'gempar',
'menggempita': 'gempita',
'penggempur': 'gempur',
'penggempurnya': 'gempur',
'penggempuran': 'gempur',
'menggempur': 'gempur',
'menggempurnya': 'gempur',
'menggempurkan': 'gempur',
'menggempuri': 'gempur',
'penggempurannya': 'gempur',
'gempur-menggempur': 'gempur',
'penggemuk': 'gemuk',
'penggemukkan': 'gemuk',
'penggemukan': 'gemuk',
'kegemukan': 'gemuk',
'kegemukannya': 'gemuk',
'kegemukanku': 'gemuk',
'penggemukannya': 'gemuk',
'menggemukkan': 'gemuk',
'menggemukkannya': 'gemuk',
'menggemulai': 'gemulai',
'segenap': 'genap',
'penggenap': 'genap',
'penggenapan': 'genap',
'kegenapan': 'genap',
'menggenapi': 'genap',
'menggenapinya': 'genap',
'menggenapkan': 'genap',
'menggenapkannya': 'genap',
'menggencar': 'gencar',
'menggencarkan': 'gencar',
'menggencarkannya': 'gencar',
'gencatan': 'gencat',
'menggencat': 'gencat',
'gencetan': 'gencet',
'tergencet': 'gencet',
'tergencetnya': 'gencet',
'menggencet': 'gencet',
'menggencetnya': 'gencet',
'bergendak': 'gendak',
'bergendakan': 'gendak',
'menggendaki': 'gendak',
'menggendalakan': 'gendala',
'gendaman': 'gendam',
'gendongan': 'gendong',
'gendongannya': 'gendong',
'gendonganku': 'gendong',
'menggendong': 'gendong',
'menggendongnya': 'gendong',
'menggendongkan': 'gendong',
'menggendongku': 'gendong',
'kegendutan': 'gendut',
'menggendut': 'gendut',
'menggendutkan': 'gendut',
'menggenduti': 'gendut',
'menggeneralisasi': 'generalisasi',
'menggeneralisasinya': 'generalisasi',
'menggeneralisasikan': 'generalisasi',
'menggeneralisasikannya': 'generalisasi',
'genggaman': 'genggam',
'genggamannya': 'genggam',
'genggamanku': 'genggam',
'genggamanmu': 'genggam',
'segenggam': 'genggam',
'segenggaman': 'genggam',
'tergenggam': 'genggam',
'bergenggam': 'genggam',
'bergenggaman': 'genggam',
'menggenggam': 'genggam',
'menggenggamnya': 'genggam',
'menggenggamkan': 'genggam',
'bergengsi': 'gengsi',
'bergengsinya': 'gengsi',
'bergengsii': 'gengsi',
'bergengsimu': 'gengsi',
'gengsi-gengsian': 'gengsi',
'kegenialan': 'genial',
'genjotan': 'genjot',
'penggenjot': 'genjot',
'penggenjotan': 'genjot',
'menggenjot': 'genjot',
'menggenjotnya': 'genjot',
'genjot-genjotan': 'genjot',
'genjrang-genjreng': 'genjrang',
'bergenre': 'genre',
'menggenta': 'genta',
'bergentar': 'gentar',
'menggentar': 'gentar',
'menggentarkan': 'gentar',
'menggentarkannya': 'gentar',
'kegentaran': 'gentar',
'penggentar': 'gentar',
'penggentaran': 'gentar',
'menggentari': 'gentar',
'menggentas': 'gentas',
'gentayangan': 'gentayang',
'gentayangannya': 'gentayang',
'bergentayangan': 'gentayangan',
'bergentayangannya': 'gentayangan',
'menggentel': 'gentel',
'menggenteli': 'gentel',
'kegentingan': 'genting',
'kegentingannya': 'genting',
'menggenting': 'genting',
'penggentingan': 'genting',
'menggentingkan': 'genting',
'gentusan': 'gentus',
'menggepit': 'gepit',
'segepok': 'gepok',
'gepokan': 'gepok',
'bergepok-gepok': 'gepok',
'menggeprak': 'geprak',
'menggera': 'gera',
'menggerakan': 'gera',
'menggerakannya': 'gera',
'menggerai': 'gera',
'penggera': 'gera',
'menggerabak': 'gerabak',
'menggerabakkan': 'gerabak',
'gerabak-gerubuk': 'gerabak',
'menggeragai': 'geragai',
'geragapan': 'geragap',
'menggeragap': 'geragap',
'menggeragas': 'geragas',
'menggeragau': 'geragau',
'kegerahan': 'gerah',
'kegerahannya': 'gerah',
'kegerahanku': 'gerah',
'tergerai': 'gerai',
'menggerainya': 'gerai',
'menggeraikan': 'gerai',
'tergerai-gerai': 'gerai',
'geraman': 'geram',
'kegeraman': 'geram',
'kegeramannya': 'geram',
'menggeram': 'geram',
'menggeramkan': 'geram',
'menggeramus': 'geramus',
'menggerang': 'gerang',
'menggerantak': 'gerantak',
'menggerantang': 'gerantang',
'menggeranyam': 'geranyam',
'menggerapai': 'gerapai',
'bergerapu': 'gerapu',
'menggerat': 'gerat',
'menggerawat': 'gerawat',
'menggerawatkan': 'gerawat',
'menggerayah': 'gerayah',
'gerayangan': 'gerayang',
'gerayangannya': 'gerayang',
'menggerayang': 'gerayang',
'menggerayangi': 'gerayang',
'bergerayangan': 'gerayang',
'menggerayanginya': 'gerayang',
'penggerayangan': 'gerayang',
'menggerbak': 'gerbak',
'menggerbang': 'gerbang',
'menggerbangkan': 'gerbang',
'tegerbang-gerbang': 'gerbang',
'menggerbus': 'gerbus',
'menggerebek': 'gerebek',
'menggerebeknya': 'gerebek',
'penggerebekan': 'gerebek',
'penggerebekannya': 'gerebek',
'menggerecak-gerecak': 'gerecak',
'menggerecok': 'gerecok',
'menggerecoki': 'gerecok',
'geregetan': 'gereget',
'geregetannya': 'gereget',
'kegerejaan': 'gereja',
'kegerejaannya': 'gereja',
'menggerek': 'gerek',
'menggerekkan': 'gerek',
'menggerekan': 'gerek',
'penggerek': 'gerek',
'penggereknya': 'gerek',
'penggerekkan': 'gerek',
'penggerekan': 'gerek',
'bergerek-gerek': 'gerek',
'menggeremet': 'geremet',
'menggerendel': 'gerendel',
'gerenengan': 'gereneng',
'menggerenik': 'gerenik',
'tergerenyeng-gerenyeng': 'gerenyeng',
'menggerenyet': 'gerenyet',
'menggerepe': 'gerepe',
'menggerepek': 'gerepek',
'bergerepes': 'gerepes',
'menggerepes': 'gerepes',
'menggeresek': 'geresek',
'geretan': 'geret',
'menggeret': 'geret',
'menggeretnya': 'geret',
'bergeretak': 'geretak',
'menggeretang': 'geretang',
'gergajian': 'gergaji',
'gergajiannya': 'gergaji',
'menggergaji': 'gergaji',
'menggergajinya': 'gergaji',
'menggergajikan': 'gergaji',
'penggergaji': 'gergaji',
'penggergajian': 'gergaji',
'penggergajiannya': 'gergaji',
'menggeriak': 'geriak',
'geriak-geriuk': 'geriak',
'menggeriap': 'geriap',
'menggericau': 'gericau',
'menggeridip': 'geridip',
'bergerilya': 'gerilya',
'bergerilyanya': 'gerilya',
'bergerilyalah': 'gerilya',
'menggerinda': 'gerinda',
'penggering': 'gering',
'geringgingan': 'geringging',
'menggerinjam': 'gerinjam',
'menggerinyau': 'gerinyau',
'menggerisik': 'gerisik',
'gerit-gerit': 'gerit',
'menggerlap': 'gerlap',
'menggerlip': 'gerlip',
'menggermang': 'germang',
'menggermut': 'germut',
'menggermuti': 'germut',
'menggero': 'gero',
'bergerobok': 'gerobok',
'menggerobok': 'gerobok',
'gerobyakan': 'gerobyak',
'bergerocok': 'gerocok',
'menggerodak': 'gerodak',
'menggerogoti': 'gerogot',
'menggerogotinya': 'gerogot',
'penggerogotan': 'gerogot',
'menggerojok': 'gerojok',
'menggerojokkan': 'gerojok',
'gerombolan': 'gerombol',
'gerombolannya': 'gerombol',
'bergerombol': 'gerombol',
'bergerombolan': 'gerombol',
'gerombongan': 'gerombong',
'menggerompok': 'gerompok',
'menggeronggang': 'geronggang',
'menggeropyok': 'geropyok',
'penggeropyokan': 'geropyok',
'menggeros': 'geros',
'menggerowot': 'gerowot',
'menggerpol': 'gerpol',
'kegersangan': 'gersang',
'gertakan': 'gertak',
'gertakannya': 'gertak',
'menggertak': 'gertak',
'menggertaknya': 'gertak',
'menggertakkan': 'gertak',
'menggertakan': 'gertak',
'menggertakku': 'gertak',
'penggertak': 'gertak',
'penggertakan': 'gertak',
'menggeru': 'geru',
'menggerugut': 'gerugut',
'menggeruh': 'geruh',
'kegeruhan': 'geruh',
'geruh-gerah': 'geruh',
'menggeruit': 'geruit',
'menggerumit': 'gerumit',
'menggerumuk': 'gerumuk',
'menggerumuti': 'gerumut',
'menggerumutinya': 'gerumut',
'menggerunkan': 'gerun',
'menggerundel': 'gerundel',
'tergerung': 'gerung',
'menggerung': 'gerung',
'menggerunyam': 'gerunyam',
'menggerupis': 'gerupis',
'menggerupuk': 'gerupuk',
'menggerupukkan': 'gerupuk',
'gerusan': 'gerus',
'gerusannya': 'gerus',
'tergerus': 'gerus',
'tergerusnya': 'gerus',
'menggerus': 'gerus',
'menggerusnya': 'gerus',
'menggerutu': 'gerutu',
'penggerutu': 'gerutu',
'menggesa': 'gesa',
'tergesa-gesa': 'gesa',
'tergesa-gesanya': 'gesa',
'bergesa-gesa': 'gesa',
'ketergesa-gesaan': 'gesa',
'menggesa-gesakan': 'gesa',
'penggetang': 'getang',
'menggetang': 'getang',
'getapan': 'getap',
'menggetap': 'getap',
'menggetik': 'getik',
'segetil': 'getil',
'menggetil': 'getil',
'kegetiran': 'getir',
'kegetirannya': 'getir',
'menggetok': 'getok',
'menggetoknya': 'getok',
'kegetolan': 'getol',
'kegetolannya': 'getol',
'menggetu': 'getu',
'getak-getuk': 'getuk',
'tergial': 'gial',
'gial-giul': 'gial',
'gial-gial': 'gial',
'pegiat': 'giat',
'pegiatnya': 'giat',
'pegiatan': 'giat',
'bergiat': 'giat',
'kegiatan': 'giat',
'kegiatannya': 'giat',
'kegiatanlah': 'giat',
'kegiatankan': 'giat',
'kegiatanan': 'giat',
'kegiatanku': 'giat',
'kegiatanmu': 'giat',
'penggiat': 'giat',
'penggiatnya': 'giat',
'penggiatan': 'giat',
'mempergiat': 'giat',
'penggiatannya': 'giat',
'menggiatkan': 'giat',
'menggiatkannya': 'giat',
'berkegiatan': 'giat',
'berkegiatanlah': 'giat',
'mempergiatkan': 'giat',
'menggibang': 'gibang',
'bergidik': 'gidik',
'menggidikkan': 'gidik',
'kegigihan': 'gigih',
'kegigihannya': 'gigih',
'kegigihannyalah': 'gigih',
'kegigihanku': 'gigih',
'kegigihanmu': 'gigih',
'menggigih': 'gigih',
'menggigil': 'gigil',
'menggigilnya': 'gigil',
'menggigilkan': 'gigil',
'menggigis': 'gigis',
'gigitan': 'gigit',
'gigitannya': 'gigit',
'gigitanku': 'gigit',
'tergigit': 'gigit',
'tergigitnya': 'gigit',
'menggigit': 'gigit',
'menggigitnya': 'gigit',
'menggigiti': 'gigit',
'menggigitku': 'gigit',
'menggigitmu': 'gigit',
'menggigitinya': 'gigit',
'kegilaan': 'gila',
'kegilaannya': 'gila',
'kegilaanmu': 'gila',
'menggila': 'gila',
'menggilanya': 'gila',
'menggilalah': 'gila',
'menggilakan': 'gila',
'menggilai': 'gila',
'penggila': 'gila',
'penggilanya': 'gila',
'gila-gila': 'gila',
'gila-gilanya': 'gila',
'gila-gilai': 'gila',
'gila-gilaan': 'gila',
'gila-gilaannya': 'gila',
'tergila-gila': 'gila',
'tergila-gilanya': 'gila',
'kegila-gilaan': 'gila',
'gilang-gemilang': 'gilang',
'gilang-gemilangnya': 'gilang',
'penggilap': 'gilap',
'menggilapkan': 'gilap',
'gilap-gemilap': 'gilap',
'gilasan': 'gilas',
'tergilas': 'gilas',
'tergilasnya': 'gilas',
'menggilas': 'gilas',
'menggilasnya': 'gilas',
'penggilas': 'gilas',
'penggilasan': 'gilas',
'gilian': 'gili',
'giliani': 'gili',
'menggili': 'gili',
'menggili-gili': 'gili',
'gilingan': 'giling',
'gilingannya': 'giling',
'tergiling': 'giling',
'penggiling': 'giling',
'penggilingnya': 'giling',
'penggilingan': 'giling',
'menggiling': 'giling',
'menggilingnya': 'giling',
'menggilingkan': 'giling',
'penggilingannya': 'giling',
'giling-giling': 'giling',
'giliran': 'gilir',
'gilirannya': 'gilir',
'giliranku': 'gilir',
'giliranmu': 'gilir',
'bergilir': 'gilir',
'bergilirnya': 'gilir',
'bergiliran': 'gilir',
'mempergilirkan': 'gilir',
'gilir-bergilir': 'gilir',
'bergilir-gilir': 'gilir',
'ginang-ginang': 'ginang',
'bergincu': 'gincu',
'menggincu': 'gincu',
'penggirang': 'girang',
'kegirangan': 'girang',
'kegirangannya': 'girang',
'menggirangkan': 'girang',
'kegirang-girangan': 'girang',
'girik-girik': 'girik',
'menggiring': 'giring',
'menggiringnya': 'giring',
'menggiringi': 'giring',
'menggisar': 'gisar',
'menggisil': 'gisil',
'menggites': 'gites',
'menggitik': 'gitik',
'tergiur': 'giur',
'tergiurnya': 'giur',
'menggiurkan': 'giur',
'menggiurkannya': 'giur',
'bergiwang': 'giwang',
'bergizi': 'gizi',
'bergizinya': 'gizi',
'keglamoran': 'glamor',
'keglamorannya': 'glamor',
'mengglasir': 'glasir',
'mengglobal': 'global',
'mengglobalnya': 'global',
'mengglobalkan': 'global',
'mengglobalkannya': 'global',
'gegoakan': 'goak',
'goak-goak': 'goak',
'menggobek': 'gobek',
'kegoblokan': 'goblok',
'gocekan': 'gocek',
'gocekannya': 'gocek',
'menggocek': 'gocek',
'menggoceknya': 'gocek',
'bergocoh': 'gocoh',
'menggocoh': 'gocoh',
'pergocohan': 'gocoh',
'godaan': 'goda',
'godaannya': 'goda',
'tergoda': 'goda',
'tergodanya': 'goda',
'menggoda': 'goda',
'menggodanya': 'goda',
'menggodaku': 'goda',
'menggodamu': 'goda',
'penggoda': 'goda',
'penggodanya': 'goda',
'penggodakan': 'goda',
'menggodai': 'goda',
'menggodainya': 'goda',
'penggodaan': 'goda',
'menggodak': 'godak',
'menggodam': 'godam',
'penggodam': 'godam',
'godokan': 'godok',
'menggodok': 'godok',
'menggodoknya': 'godok',
'penggodokan': 'godok',
'penggodokannya': 'godok',
'menggodot': 'godot',
'menggodot-godot': 'godot',
'menggoel': 'goel',
'menggogoh': 'gogoh',
'menggogok': 'gogok',
'bergojek': 'gojek',
'gojlokan': 'gojlok',
'gojlokannya': 'gojlok',
'menggojlok': 'gojlok',
'menggojloki': 'gojlok',
'penggojlokan': 'gojlok',
'menggolak-galikkan': 'golak-galik',
'menggoleng': 'goleng',
'bergoler': 'goler',
'pegolf': 'golf',
'pegolfnya': 'golf',
'bergolok': 'golok',
'tergolok': 'golok',
'menggolok': 'golok',
'golongan': 'golong',
'golongannya': 'golong',
'golonganku': 'golong',
'golonganmu': 'golong',
'tergolong': 'golong',
'tergolongkan': 'golong',
'tergolongan': 'golong',
'penggolong': 'golong',
'penggolongkan': 'golong',
'penggolongan': 'golong',
'menggolong': 'golong',
'menggolongkan': 'golong',
'menggolongkannya': 'golong',
'menggolongan': 'golong',
'penggolongannya': 'golong',
'bergolong-golong': 'golong',
'gombalan': 'gombal',
'gombalannya': 'gombal',
'menggombeng': 'gombeng',
'menggondokkan': 'gondok',
'menggondol': 'gondol',
'menggondolnya': 'gondol',
'menggondolkan': 'gondol',
'kegondrongan': 'gondrong',
'gonggongan': 'gonggong',
'gonggongannya': 'gonggong',
'menggonggong': 'gonggong',
'menggonggongi': 'gonggong',
'pergonglian': 'gongli',
'menggongseng': 'gongseng',
'penggongsengan': 'gongseng',
'menggonjakkan': 'gonjak',
'gonjang-ganjing': 'gonjang',
'gonjang-ganjingnya': 'gonjang',
'gonjlang-ganjling': 'gonjlang',
'menggonjokkan': 'gonjok',
'bergonjong': 'gonjong',
'bergontai': 'gontai',
'menggontai': 'gontai',
'mempergontai': 'gontai',
'tergontai-gontai': 'gontai',
'bergontok': 'gontok',
'bergontokan': 'gontok',
'gontok-gontokan': 'gontok',
'menggonyakkan': 'gonyak',
'menggonyeh': 'gonyeh',
'menggonyel': 'gonyel',
'menggonyoh': 'gonyoh',
'tergopoh': 'gopoh',
'gorap-gorap': 'gorap',
'menggorek-gorek': 'gorek',
'gorengan': 'goreng',
'gorengannya': 'goreng',
'menggoreng': 'goreng',
'menggorengnya': 'goreng',
'penggorengan': 'goreng',
'penggorengannya': 'goreng',
'menggoreng-goreng': 'goreng',
'menggoroh': 'goroh',
'menggorok': 'gorok',
'menggoroknya': 'gorok',
'menggorokkan': 'gorok',
'menggorokan': 'gorok',
'menggorokmu': 'gorok',
'penggorokan': 'gorok',
'penggorokannya': 'gorok',
'bergosip': 'gosip',
'bergosiplah': 'gosip',
'penggosip': 'gosip',
'pergosipan': 'gosip',
'menggosipkan': 'gosip',
'menggosipkannya': 'gosip',
'gosokan': 'gosok',
'gosokannya': 'gosok',
'bergosok': 'gosok',
'menggosok': 'gosok',
'menggosoknya': 'gosok',
'menggosokkan': 'gosok',
'menggosokkannya': 'gosok',
'menggosoki': 'gosok',
'menggosokan': 'gosok',
'penggosok': 'gosok',
'penggosoknya': 'gosok',
'penggosokan': 'gosok',
'bergosokan': 'gosok',
'penggosokannya': 'gosok',
'mempergosokkan': 'gosok',
'menggosok-gosok': 'gosok',
'menggosok-gosoknya': 'gosok',
'menggosok-gosokkan': 'gosok',
'menggosok-gosokkannya': 'gosok',
'menggosok-gosokan': 'gosok',
'bergosong': 'gosong',
'menggotes': 'gotes',
'menggotong': 'gotong',
'menggotongnya': 'gotong',
'bergotong royong': 'gotong royong',
'kegotongroyongan': 'gotong royong',
'kegotongroyongannya': 'gotong royong',
'bergoyah': 'goyah',
'kegoyahan': 'goyah',
'tergoyahkan': 'goyah',
'tergoyahkannya': 'goyah',
'menggoyahkan': 'goyah',
'menggoyahkannya': 'goyah',
'menggoyak': 'goyak',
'menggoyakan': 'goyak',
'kegramatikalan': 'gramatikal',
'menggranat': 'granat',
'penggranatan': 'granat',
'bergranula': 'granula',
'menggrataki': 'gratak',
'menggratiskan': 'gratis',
'menggratiskannya': 'gratis',
'menggraver': 'graver',
'grempelan': 'grempel',
'menggual': 'gual',
'gual-gail': 'gual',
'peguam': 'guam',
'berguam': 'guam',
'perguaman': 'guam',
'mengguar': 'guar',
'gubahan': 'gubah',
'gubahannya': 'gubah',
'penggubah': 'gubah',
'penggubahnya': 'gubah',
'penggubahan': 'gubah',
'menggubah': 'gubah',
'menggubahnya': 'gubah',
'penggubahannya': 'gubah',
'menggubal': 'gubal',
'menggubel': 'gubel',
'kegubernuran': 'gubernur',
'kegubernurannya': 'gubernur',
'menggubit': 'gubit',
'gubrisan': 'gubris',
'menggubris': 'gubris',
'menggubrisnya': 'gubris',
'menggubrislah': 'gubris',
'menggubriskan': 'gubris',
'pergudangan': 'gudang',
'pergudangannya': 'gudang',
'penggudangan': 'gudang',
'menggudangkan': 'gudang',
'menggudangkannya': 'gudang',
'tergudik-gudik': 'gudik',
'gugahan': 'gugah',
'tergugah': 'gugah',
'tergugahnya': 'gugah',
'tergugahkan': 'gugah',
'menggugah': 'gugah',
'menggugahnya': 'gugah',
'menggugahkan': 'gugah',
'penggugah': 'gugah',
'penggugahan': 'gugah',
'gugatan': 'gugat',
'gugatannya': 'gugat',
'tergugat': 'gugat',
'tergugatnya': 'gugat',
'penggugat': 'gugat',
'penggugatnya': 'gugat',
'penggugatan': 'gugat',
'menggugat': 'gugat',
'menggugatnya': 'gugat',
'menggugatkan': 'gugat',
'menggugatan': 'gugat',
'penggugatannya': 'gugat',
'menggugu': 'gugu',
'menggugukan': 'guguk',
'tergugu-gugu': 'gugu',
'mengguguh': 'guguh',
'terguguk': 'guguk',
'mengguguk': 'guguk',
'penggugup': 'gugup',
'kegugupan': 'gugup',
'kegugupannya': 'gugup',
'kegugupanmu': 'gugup',
'menggugupkan': 'gugup',
'guguran': 'gugur',
'gugurannya': 'gugur',
'keguguran': 'gugur',
'kegugurannya': 'gugur',
'berguguran': 'gugur',
'bergugurannya': 'gugur',
'pengguguran': 'gugur',
'menggugurkan': 'gugur',
'menggugurkannya': 'gugur',
'menggugurkanmu': 'gugur',
'gugusan': 'gugus',
'gugusannya': 'gugus',
'bergugus-gugus': 'gugus',
'mengguit': 'guit',
'mengguit-guit': 'guit',
'bergula': 'gula',
'menggula': 'gula',
'menggulai': 'gulai',
'pergulaan': 'gula',
'gula-gula': 'gula',
'gula-gulanya': 'gula',
'kegulanaan': 'gulana',
'pegulat': 'gulat',
'pegulatnya': 'gulat',
'pegulatku': 'gulat',
'bergulat': 'gulat',
'pergulatan': 'gulat',
'pergulatannya': 'gulat',
'bergulir': 'gulir',
'bergulirnya': 'gulir',
'bergulirlah': 'gulir',
'bergulirkan': 'gulir',
'berguliran': 'gulir',
'tergulir': 'gulir',
'menggulir': 'gulir',
'menggulirnya': 'gulir',
'menggulirkan': 'gulir',
'menggulirkannya': 'gulir',
'mengguliran': 'gulir',
'pengguliran': 'gulir',
'guludan': 'gulud',
'gulungan': 'gulung',
'gulungannya': 'gulung',
'tergulung': 'gulung',
'bergulung': 'gulung',
'menggulung': 'gulung',
'menggulungnya': 'gulung',
'menggulungkan': 'gulung',
'menggulungku': 'gulung',
'penggulungan': 'gulung',
'bergulung-gulung': 'gulung',
'gulung-menggulung': 'gulung',
'tergulut': 'gulut',
'bergulut': 'gulut',
'menggulut': 'gulut',
'tergulut-gulut': 'gulut',
'bergulut-gulut': 'gulut',
'menggumalkan': 'gumal',
'menggumbuk': 'gumbuk',
'segumpal': 'gumpa',
'segumpalan': 'gumpa',
'bergumul': 'gumul',
'bergumulnya': 'gumul',
'bergumulan': 'gumul',
'menggumuli': 'gumul',
'pergumulan': 'gumul',
'pergumulannya': 'gumul',
'guncangan': 'guncang',
'guncangannya': 'guncang',
'terguncang': 'guncang',
'terguncangnya': 'guncang',
'terguncanglah': 'guncang',
'terguncangkan': 'guncang',
'berguncang': 'guncang',
'berguncangan': 'guncang',
'keguncangan': 'guncang',
'mengguncangkan': 'guncang',
'mengguncangkannya': 'guncang',
'kegundahan': 'gundah',
'kegundahannya': 'gundah',
'mempergundah': 'gundah',
'menggundahkan': 'gundah',
'gundalan': 'gundal',
'pergundalan': 'gundal',
'gundala-gundala': 'gundala',
'pergundikan': 'gundik',
'mempergundik': 'gundik',
'mempergundikkan': 'gundik',
'bergundu': 'gundu',
'gundukan': 'gunduk',
'gundukannya': 'gunduk',
'bergunduk-gunduk': 'gunduk',
'bergundul': 'gundul',
'menggundul': 'gundul',
'menggundulkan': 'gundul',
'menggunduli': 'gundul',
'menggundulinya': 'gundul',
'penggundulan': 'gundul',
'penggundulannya': 'gundul',
'mengegungkan': 'gung',
'menggunggung': 'gunggung',
'gunjingan': 'gunjing',
'gunjingannya': 'gunjing',
'bergunjing': 'gunjing',
'menggunjing': 'gunjing',
'menggunjingnya': 'gunjing',
'menggunjingkan': 'gunjing',
'menggunjingkannya': 'gunjing',
'pergunjingan': 'gunjing',
'pergunjingannya': 'gunjing',
'mempergunjingkan': 'gunjing',
'mempergunjingkannya': 'gunjing',
'guntang-guntang': 'guntang',
'guntingan': 'gunting',
'guntingannya': 'gunting',
'penggunting': 'gunting',
'pengguntingan': 'gunting',
'menggunting': 'gunting',
'mengguntingnya': 'gunting',
'mengguntingkan': 'gunting',
'mengguntung': 'guntung',
'mengguntungkan': 'guntung',
'mengguntur': 'guntur',
'menggunturkan': 'guntur',
'gunungan': 'gunung',
'gunungannya': 'gunung',
'pegunungan': 'gunung',
'pegunungannya': 'gunung',
'menggunung': 'gunung',
'menggunungnya': 'gunung',
'menggununglah': 'gunung',
'gunung-ganang': 'gunung',
'gunung-gemunung': 'gunung',
'gunung-gunungan': 'gunung',
'bergunung-gunung': 'gunung',
'menggunyam': 'gunyam',
'bergurah': 'gurah',
'menggurah': 'gurah',
'mengguram': 'guram',
'keguraman': 'guram',
'guratan': 'gurat',
'guratannya': 'gurat',
'tergurat': 'gurat',
'menggurat': 'gurat',
'mengguratnya': 'gurat',
'mengguratkan': 'gurat',
'menggurdi': 'gurdi',
'menggurik': 'gurik',
'bergurindam': 'gurindam',
'guritan': 'gurit',
'menggurit': 'gurit',
'menggurita': 'gurita',
'mengguritanya': 'gurita',
'berguru': 'guru',
'bergurunya': 'guru',
'bergurulah': 'guru',
'keguruan': 'guru',
'menggurui': 'guru',
'mengguruinya': 'guru',
'perguruan': 'guru',
'perguruannya': 'guru',
'mengguruh': 'guruh',
'menggusah': 'gusah',
'kegusaran': 'gusar',
'kegusarannya': 'gusar',
'menggusari': 'gusar',
'menggusarkan': 'gusar',
'menggusel': 'gusel',
'menggusrek': 'gusrek',
'gusuran': 'gusur',
'gusurannya': 'gusur',
'tergusur': 'gusur',
'tergusurnya': 'gusur',
'menggusur': 'gusur',
'menggusurnya': 'gusur',
'pergusuran': 'gusur',
'penggusuran': 'gusur',
'penggusurannya': 'gusur',
'menggutik': 'gutik',
'guyonan': 'guyon',
'guyonannya': 'guyon',
'guyonannyalah': 'guyon',
'guyonanmu': 'guyon',
'berguyub': 'guyub',
'peguyuban': 'guyub',
'terguyur': 'guyur',
'mengguyur': 'guyur',
'mengguyurnya': 'guyur',
'mengguyurkan': 'guyur',
'mengguyurkannya': 'guyur',
'mengguyuri': 'guyur',
'sehabis': 'habis',
'sehabisnya': 'habis',
'berhabis': 'habis',
'kehabisan': 'habis',
'kehabisanlah': 'habis',
'menghabisi': 'habis',
'menghabisinya': 'habis',
'menghabisikan': 'habis',
'menghabisiku': 'habis',
'menghabisimu': 'habis',
'habis-habis': 'habis',
'habis-habisnya': 'habis',
'habis-habiskan': 'habis',
'habis-habisan': 'habis',
'terhabiskan': 'habis',
'penghabisan': 'habis',
'penghabisannya': 'habis',
'menghabiskan': 'habis',
'menghabiskannya': 'habis',
'menghabiskankan': 'habis',
'sehabis-habisnya': 'habis',
'menghablur': 'hablur',
'penghabluran': 'hablur',
'menghablurkan': 'hablur',
'berhad': 'had',
'berhadan': 'had',
'terhad': 'had',
'terhadi': 'had',
'terhadan': 'had',
'menghadkan': 'had',
'hadapan': 'hadap',
'hadapannya': 'hadap',
'hadapanku': 'hadap',
'hadapanmu': 'hadap',
'terhadap': 'hadap',
'terhadapnya': 'hadap',
'terhadapi': 'hadap',
'terhadapan': 'hadap',
'terhadapku': 'hadap',
'terhadapmu': 'hadap',
'terhadap-mu': 'hadap',
'menghadap': 'hadap',
'menghadapnya': 'hadap',
'menghadaplah': 'hadap',
'menghadapkan': 'hadap',
'menghadapkannya': 'hadap',
'menghadapi': 'hadap',
'menghadapan': 'hadap',
'menghadapku': 'hadap',
'menghadapmu': 'hadap',
'bersehadap': 'hadap',
'menghadapinya': 'hadap',
'menghadapii': 'hadap',
'menghadapiku': 'hadap',
'menghadapimu': 'hadap',
'penghadapan': 'hadap',
'memperhadapkan': 'hadap',
'berhadap-hadapan': 'hadap',
'berhadapan': 'hadap',
'berhadiah': 'hadiah',
'berhadiahkan': 'hadiah',
'menghadiahkan': 'hadiah',
'menghadiahkannya': 'hadiah',
'berhadir': 'hadir',
'berhadirkan': 'hadir',
'kehadiran': 'hadir',
'kehadirannya': 'hadir',
'kehadiranan': 'hadir',
'kehadiranku': 'hadir',
'kehadiranmu': 'hadir',
'menghadiri': 'hadir',
'menghadirinya': 'hadir',
'menghadirikan': 'hadir',
'menghadirkan': 'hadir',
'menghadirkannya': 'hadir',
'menghadirkanku': 'hadir',
'hafalan': 'hafal',
'hafalannya': 'hafal',
'menghafal': 'hafal',
'menghafalnya': 'hafal',
'menghafalkan': 'hafal',
'menghafalkannya': 'hafal',
'menghafalan': 'hafal',
'menghajar': 'hajar',
'menghajarnya': 'hajar',
'menghajarkan': 'hajar',
'menghajari': 'hajar',
'menghajarmu': 'hajar',
'berhaji': 'haji',
'berhajinya': 'haji',
'kehajian': 'haji',
'perhajian': 'haji',
'menghajikan': 'haji',
'berhak': 'hak',
'berhaknya': 'hak',
'berhaklah': 'hak',
'menghaki': 'hak',
'menghakikan': 'hak',
'menghakkan': 'hak',
'berhakim': 'hakim',
'kehakiman': 'hakim',
'kehakimannya': 'hakim',
'menghakimi': 'hakim',
'menghakiminya': 'hakim',
'menghakimilah': 'hakim',
'menghakimiku': 'hakim',
'menghakimimu': 'hakim',
'penghakiman': 'hakim',
'penghakimannya': 'hakim',
'berhal': 'hal',
'berhalan': 'hal',
'terhal': 'hal',
'terhalan': 'hal',
'menghalai-balaikan': 'halai-balai',
'penghalal': 'halal',
'penghalalan': 'halal',
'kehalalan': 'halal',
'kehalalannya': 'halal',
'menghalalkan': 'halal',
'berhalalbihalal': 'halalbihalal',
'halangan': 'halang',
'halangannya': 'halang',
'terhalang': 'halang',
'terhalangnya': 'halang',
'terhalangi': 'halang',
'penghalang': 'halang',
'penghalangnya': 'halang',
'penghalangan': 'halang',
'menghalang': 'halang',
'menghalangnya': 'halang',
'menghalangkan': 'halang',
'menghalangi': 'halang',
'menghalangan': 'halang',
'berhalangan': 'halang',
'berhalangannya': 'halang',
'menghalanginya': 'halang',
'menghalangiku': 'halang',
'menghalangimu': 'halang',
'menghalang-halangi': 'halang',
'menghalang-halanginya': 'halang',
'menghalau': 'halau',
'menghalaunya': 'halau',
'menghalaukan': 'halau',
'penghalau': 'halau',
'penghalauan': 'halau',
'sehaluan': 'haluan',
'berhaluan': 'haluan',
'kehalusan': 'halus',
'kehalusannya': 'halus',
'menghalusi': 'halus',
'memperhalus': 'halus',
'memperhalusnya': 'halus',
'menghaluskan': 'halus',
'menghaluskannya': 'halus',
'berhamba': 'hamba',
'menghamba': 'hamba',
'menghambakan': 'hamba',
'menghambai': 'hamba',
'perhambaan': 'hamba',
'penghambaan': 'hamba',
'penghambaannya': 'hamba',
'memperhamba': 'hamba',
'memperhambakan': 'hamba',
'kehambaran': 'hambar',
'hambatan': 'hambat',
'hambatannya': 'hambat',
'hambatanmu': 'hambat',
'terhambat': 'hambat',
'terhambatnya': 'hambat',
'terhambatlah': 'hambat',
'terhambatan': 'hambat',
'menghambat': 'hambat',
'menghambatnya': 'hambat',
'menghambatkan': 'hambat',
'menghambatku': 'hambat',
'menghambatmu': 'hambat',
'penghambat': 'hambat',
'penghambatnya': 'hambat',
'penghambatan': 'hambat',
'penghambatannya': 'hambat',
'memperhambat': 'hambat',
'terhambat-hambat': 'hambat',
'kehamilan': 'hamil',
'kehamilannya': 'hamil',
'kehamilanlah': 'hamil',
'kehamilanan': 'hamil',
'kehamilanku': 'hamil',
'menghamili': 'hamil',
'menghamilinya': 'hamil',
'menghamiliku': 'hamil',
'penghamilan': 'hamil',
'menghamilkan': 'hamil',
'kehampaan': 'hampa',
'kehampaannya': 'hampa',
'menghampakan': 'hampa',
'hamparan': 'hampar',
'hamparannya': 'hampar',
'terhampar': 'hampar',
'sehamparan': 'hampar',
'menghampar': 'hampar',
'menghamparkan': 'hampar',
'menghampari': 'hampar',
'hampirkan': 'hampir',
'menghampiri': 'hampir',
'menghampirinya': 'hampir',
'menghampiriku': 'hampir',
'menghampirimu': 'hampir',
'hampir-hampir': 'hampir',
'hampir-hampiran': 'hampir',
'menghampirkan': 'hampir',
'berhampiran': 'hampir',
'menghamuni': 'hamun',
'berhamun-hamun': 'hamun',
'kehancuran': 'hancur',
'kehancurannya': 'hancur',
'penghancuran': 'hancur',
'penghancurannya': 'hancur',
'menghancurkan': 'hancur',
'menghancurkannya': 'hancur',
'menghancurkanku': 'hancur',
'menghancurkanmu': 'hancur',
'hancur-hancuran': 'hancur',
'hancur-menghancurkan': 'hancur',
'penghancurleburan': 'hancur lebur',
'menghancurleburkan': 'hancur lebur',
'menghancurluluhkan': 'hancur luluh',
'berhandai-handai': 'handai',
'menghangat': 'hangat',
'menghangatnya': 'hangat',
'menghangatkan': 'hangat',
'menghangatkannya': 'hangat',
'menghangati': 'hangat',
'penghangat': 'hangat',
'penghangatan': 'hangat',
'kehangatan': 'hangat',
'kehangatannya': 'hangat',
'menghangatinya': 'hangat',
'menghangatkanku': 'hangat',
'kehangusan': 'hangus',
'menghangus': 'hangus',
'menghangusnya': 'hangus',
'menghanguskan': 'hangus',
'menghanguskannya': 'hangus',
'menghangusan': 'hangus',
'hantaman': 'hantam',
'hantamannya': 'hantam',
'berhantam': 'hantam',
'berhantaman': 'hantam',
'menghantam': 'hantam',
'menghantamnya': 'hantam',
'menghantamkan': 'hantam',
'menghantamkannya': 'hantam',
'menghantami': 'hantam',
'menghantamku': 'hantam',
'menghantammu': 'hantam',
'hantaran': 'hantar',
'hantarannya': 'hantar',
'terhantar': 'hantar',
'terhantarkan': 'hantar',
'berhantar': 'hantar',
'menghantar': 'hantar',
'menghantarnya': 'hantar',
'menghantarkan': 'hantar',
'menghantarkannya': 'hantar',
'penghantar': 'hantar',
'penghantarnya': 'hantar',
'penghantaran': 'hantar',
'berhantaran': 'hantar',
'menghantarkankan': 'hantar',
'menghantarkanku': 'hantar',
'menghantarkanmu': 'hantar',
'berhanyut': 'hanyut',
'berhanyutan': 'hanyut',
'terhanyut': 'hanyut',
'penghanyutan': 'hanyut',
'menghanyutkan': 'hanyut',
'menghanyutkannya': 'hanyut',
'menghanyutkankan': 'hanyut',
'berhanyut-hanyut': 'hanyut',
'terhapus': 'hapus',
'terhapusnya': 'hapus',
'terhapuskan': 'hapus',
'penghapus': 'hapus',
'penghapusnya': 'hapus',
'penghapuskan': 'hapus',
'penghapusan': 'hapus',
'menghapus': 'hapus',
'menghapusnya': 'hapus',
'menghapuskan': 'hapus',
'menghapuskannya': 'hapus',
'menghapusan': 'hapus',
'menghapusmu': 'hapus',
'penghapusannya': 'hapus',
'terharak-harak': 'harak',
'pengharaman': 'haram',
'mengharamkan': 'haram',
'mengharamkannya': 'haram',
'harapan': 'harap',
'harapannya': 'harap',
'harapanlah': 'harap',
'harapankan': 'harap',
'harapanku': 'harap',
'harapanmu': 'harap',
'berharap': 'harap',
'berharapnya': 'harap',
'berharaplah': 'harap',
'berharapkan': 'harap',
'berharapan': 'harap',
'mengharap': 'harap',
'mengharapnya': 'harap',
'mengharaplah': 'harap',
'mengharapkan': 'harap',
'mengharapkannya': 'harap',
'mengharapi': 'harap',
'mengharapan': 'harap',
'harap-harap': 'harap',
'pengharapan': 'harap',
'pengharapannya': 'harap',
'mengharapkanku': 'harap',
'harap-harapan': 'harap',
'berpengharapan': 'harap',
'terharap-harap': 'harap',
'harap-harap cemas': 'harap',
'hardikan': 'hardik',
'hardikannya': 'hardik',
'menghardik': 'hardik',
'menghardiknya': 'hardik',
'harian': 'hari',
'hariannya': 'hari',
'harianlah': 'hari',
'hariani': 'hari',
'harianku': 'hari',
'harianmu': 'hari',
'sehari': 'hari',
'seharinya': 'hari',
'seharian': 'hari',
'berhari': 'hari',
'sehariannya': 'hari',
'keseharian': 'hari',
'kesehariannya': 'hari',
'keseharianku': 'hari',
'keseharianmu': 'hari',
'sehari-hari': 'hari',
'sehari-harinya': 'hari',
'sehari-harilah': 'hari',
'sehari-hariku': 'hari',
'sehari-harimu': 'hari',
'berhari-hari': 'hari',
'sehari-harian': 'hari',
'mengharimau': 'harimau',
'pengharit': 'harit',
'pengharkatan': 'harkat',
'mengharmonikan': 'harmoni',
'keharmonisan': 'harmonis',
'keharmonisannya': 'harmonis',
'pengharmonisan': 'harmonis',
'mengharmoniskan': 'harmonis',
'mengharmoniskannya': 'harmonis',
'berharta': 'harta',
'terharu biru': 'haru biru',
'mengharu biru': 'haru biru',
'mengharubirukan': 'haru biru',
'terharu': 'haru',
'terharunya': 'haru',
'terharulah': 'haru',
'pengharu': 'haru',
'keharuan': 'haru',
'keharuannya': 'haru',
'mengharu': 'haru',
'mengharukan': 'haru',
'mengharukannya': 'haru',
'mengharukanku': 'haru',
'keterharuan': 'haru',
'keterharuannya': 'haru',
'mengharum': 'harum',
'mengharumkan': 'harum',
'mengharumi': 'harum',
'keharuman': 'harum',
'keharumannya': 'harum',
'harum-haruman': 'harum',
'keharusan': 'harus',
'keharusannya': 'harus',
'seharusnya': 'harus',
'seharusnyanya': 'harus',
'seharusnyalah': 'harus',
'seharusnyakan': 'harus',
'mengharuskan': 'harus',
'mengharuskannya': 'harus',
'mengharuskanku': 'harus',
'mengharuskanmu': 'harus',
'sehasta': 'hasta',
'menghasta': 'hasta',
'menghasud': 'hasud',
'terhasut': 'hasut',
'penghasut': 'hasut',
'penghasutnya': 'hasut',
'penghasutan': 'hasut',
'menghasut': 'hasut',
'menghasutnya': 'hasut',
'penghasutannya': 'hasut',
'penghasutani': 'hasut',
'sehati': 'hati',
'sehatinya': 'hati',
'berhati': 'hati',
'berhatian': 'hati',
'hati-hati': 'hati',
'hati-hatinya': 'hati',
'hati-hatilah': 'hati',
'hati-hatian': 'hati',
'berhati-hati': 'hati',
'berhati-hatinya': 'hati',
'berhati-hatilah': 'hati',
'berhati-hatii': 'hati',
'berhati-hatian': 'hati',
'kehati-hatian': 'hati',
'kehati-hatiannya': 'hati',
'kehausan': 'haus',
'kehausannya': 'haus',
'menghauskan': 'haus',
'berhawa': 'hawa',
'menghawa': 'hawa',
'penghawaan': 'hawa',
'menghawakan': 'hawa',
'penghayat': 'hayat',
'penghayatnya': 'hayat',
'penghayatan': 'hayat',
'menghayati': 'hayat',
'menghayatinya': 'hayat',
'penghayatannya': 'hayat',
'mengheban': 'heban',
'kehebatan': 'hebat',
'kehebatannya': 'hebat',
'kehebatanku': 'hebat',
'kehebatanmu': 'hebat',
'menghebat': 'hebat',
'menghebatnya': 'hebat',
'menghebatkan': 'hebat',
'memperhebat': 'hebat',
'hebat-hebatan': 'hebat',
'kehebohan': 'heboh',
'kehebohannya': 'heboh',
'menghebohkan': 'heboh',
'menghebohkannya': 'heboh',
'berhektare-hektare': 'hektare',
'helaan': 'hela',
'menghela': 'hela',
'menghelanya': 'hela',
'menghelakan': 'hela',
'penghela': 'hela',
'penghelanya': 'hela',
'sehelai': 'helai',
'sehelainya': 'helai',
'berhelai': 'helai',
'berhelat': 'helat',
'berhelatan': 'helat',
'menghelat': 'helat',
'menghelatnya': 'helat',
'perhelatan': 'helat',
'perhelatannya': 'helat',
'perhelatanan': 'helat',
'terhembalang': 'hembalang',
'berhembalang': 'hembalang',
'menghembalang': 'hembalang',
'menghembalangkan': 'hembalang',
'terhempap': 'hempap',
'menghempap': 'hempap',
'menghempapkan': 'hempap',
'hempasan': 'hempas',
'hempasannya': 'hempas',
'terhempas': 'hempas',
'terhempasnya': 'hempas',
'menghempas': 'hempas',
'menghempasnya': 'hempas',
'menghempaskan': 'hempas',
'menghempaskannya': 'hempas',
'penghempasan': 'hempas',
'kehendak': 'hendak',
'kehendaknya': 'hendak',
'kehendakkan': 'hendak',
'kehendaki': 'hendak',
'kehendakku': 'hendak',
'kehendakmu': 'hendak',
'kehendak-mu': 'hendak',
'hendaklah': 'hendak',
'sekehendak': 'hendak',
'sekehendaknya': 'hendak',
'menghendaki': 'hendak',
'menghendakinya': 'hendak',
'berkehendak': 'hendak',
'terhengit-hengit': 'hengit',
'keheningan': 'hening',
'keheningannya': 'hening',
'pengheningan': 'hening',
'mengheningkan': 'hening',
'penghentar': 'hentar',
'keheranan': 'heran',
'keheranannya': 'heran',
'keherananan': 'heran',
'keherananku': 'heran',
'mengherani': 'heran',
'mengherankan': 'heran',
'mengherankannya': 'heran',
'mengherankankan': 'heran',
'mengherankanku': 'heran',
'terheran-heran': 'heran',
'keheran-heranan': 'heran',
'keheroikan': 'heroik',
'keheterogenan': 'heterogen',
'kehewanan': 'hewan',
'kehewanannya': 'hewan',
'hibahan': 'hibah',
'penghibahan': 'hibah',
'menghibahkan': 'hibah',
'menghibahkannya': 'hibah',
'kehibukan': 'hibuk',
'hiburan': 'hibur',
'hiburannya': 'hibur',
'hiburanmu': 'hibur',
'terhibur': 'hibur',
'terhiburnya': 'hibur',
'terhiburlah': 'hibur',
'penghibur': 'hibur',
'penghiburnya': 'hibur',
'penghiburan': 'hibur',
'penghiburku': 'hibur',
'menghibur': 'hibur',
'menghiburnya': 'hibur',
'menghiburlah': 'hibur',
'menghiburkan': 'hibur',
'menghiburan': 'hibur',
'menghiburku': 'hibur',
'menghiburmu': 'hibur',
'penghiburannya': 'hibur',
'hidangan': 'hidang',
'hidangannya': 'hidang',
'hidanganmu': 'hidang',
'terhidang': 'hidang',
'sehidangan': 'hidang',
'berhidangan': 'hidang',
'penghidangan': 'hidang',
'menghidangkan': 'hidang',
'menghidangkannya': 'hidang',
'menghidrogenasi': 'hidrogenasi',
'menghidrolisis': 'hidrolisis',
'menghidroponikkan': 'hidroponik',
'penghidu': 'hidu',
'menghidu': 'hidu',
'menghidukan': 'hidu',
'penghiduan': 'hidu',
'kehidupan': 'hidup',
'kehidupannya': 'hidup',
'kehidupanan': 'hidup',
'kehidupanku': 'hidup',
'kehidupanmu': 'hidup',
'menghidupi': 'hidup',
'menghidupinya': 'hidup',
'menghidupimu': 'hidup',
'memperhidup': 'hidup',
'penghidupan': 'hidup',
'penghidupannya': 'hidup',
'menghidupkan': 'hidup',
'menghidupkannya': 'hidup',
'menghierarkikan': 'hierarki',
'berhijau daun': 'hijau daun',
'hijauan': 'hijau',
'hijauannya': 'hijau',
'penghijau': 'hijau',
'penghijauan': 'hijau',
'menghijau': 'hijau',
'menghijaunya': 'hijau',
'menghijaukan': 'hijau',
'penghijauannya': 'hijau',
'kehijau-hijauan': 'hijau',
'penghijrahan': 'hijrah',
'menghijrahkan': 'hijrah',
'menghijrahkannya': 'hijrah',
'berhikayat': 'hikayat',
'menghikayatkan': 'hikayat',
'berhikmah': 'hikmah',
'menghilang': 'hilang',
'menghilangnya': 'hilang',
'menghilanglah': 'hilang',
'menghilangkan': 'hilang',
'menghilangkannya': 'hilang',
'menghilangi': 'hilang',
'menghilangan': 'hilang',
'kehilangan': 'hilang',
'kehilangannya': 'hilang',
'kehilanganlah': 'hilang',
'kehilanganan': 'hilang',
'kehilanganku': 'hilang',
'kehilanganmu': 'hilang',
'penghilangan': 'hilang',
'penghilangannya': 'hilang',
'hilang-hilang': 'hilang',
'hilang-hilangan': 'hilang',
'menghilangkani': 'hilang',
'berhilau': 'hilau',
'berhilau-hilau': 'hilau',
'sehilir': 'hilir',
'menghilir': 'hilir',
'menghilirkan': 'hilir',
'berhiliran': 'hilir',
'menghiliri': 'hilir',
'himpunan': 'himpun',
'himpunanan': 'himpun',
'berhimpun': 'himpun',
'berhimpunnya': 'himpun',
'berhimpunan': 'himpun',
'terhimpun': 'himpun',
'terhimpunnya': 'himpun',
'terhimpunlah': 'himpun',
'menghimpun': 'himpun',
'menghimpunnya': 'himpun',
'menghimpunan': 'himpun',
'perhimpunan': 'himpun',
'perhimpunannya': 'himpun',
'penghimpunan': 'himpun',
'penghimpunannya': 'himpun',
'menghimpunkan': 'himpun',
'menghinadinakan': 'hina dina',
'hinaan': 'hina',
'hinaannya': 'hina',
'sehina': 'hina',
'terhina': 'hina',
'terhinanya': 'hina',
'terhinakan': 'hina',
'berhina': 'hina',
'menghina': 'hina',
'menghinanya': 'hina',
'menghinalah': 'hina',
'menghinakan': 'hina',
'menghinakannya': 'hina',
'menghinaku': 'hina',
'menghinamu': 'hina',
'kehinaan': 'hina',
'penghinaan': 'hina',
'penghinaannya': 'hina',
'penghinaanlah': 'hina',
'hina-menghinakan': 'hina',
'menghinap-hinap': 'hinap',
'terhindar': 'hindar',
'terhindarnya': 'hindar',
'terhindarlah': 'hindar',
'terhindarkan': 'hindar',
'terhindarkannya': 'hindar',
'terhindari': 'hindar',
'menghindar': 'hindar',
'menghindarnya': 'hindar',
'menghindarlah': 'hindar',
'menghindarkan': 'hindar',
'menghindarkannya': 'hindar',
'menghindari': 'hindar',
'menghindarinya': 'hindar',
'menghindarikan': 'hindar',
'menghindariku': 'hindar',
'menghindarimu': 'hindar',
'penghindaran': 'hindar',
'penghindarannya': 'hindar',
'berhindu': 'hindu',
'berhingga': 'hingga',
'terhingga': 'hingga',
'perhinggaan': 'hingga',
'menghinggakan': 'hingga',
'menghinggakannya': 'hingga',
'memperhinggakan': 'hingga',
'menghinggapi': 'hinggap',
'menghinggapinya': 'hinggap',
'menghinggapiku': 'hinggap',
'menghinggut': 'hinggut',
'terhinggut-hinggut': 'hinggut',
'menghipnosis': 'hipnosis',
'menghipnosisnya': 'hipnosis',
'kehiponiman': 'hiponim',
'menghirap': 'hirap',
'menghiraukan': 'hirau',
'menghiraukannya': 'hirau',
'menghiraukanku': 'hirau',
'menghiruk': 'hiruk',
'penghiruk': 'hiruk',
'menghirukkan': 'hiruk',
'menghirup': 'hirup',
'menghirupnya': 'hirup',
'penghirupan': 'hirup',
'terhisab': 'hisab',
'menghisab': 'hisab',
'menghisabkan': 'hisab',
'menghitam': 'hitam',
'menghitamnya': 'hitam',
'menghitamkan': 'hitam',
'menghitamkannya': 'hitam',
'penghitam': 'hitam',
'penghitaman': 'hitam',
'kehitaman': 'hitam',
'menghitami': 'hitam',
'kehitam-hitaman': 'hitam',
'kehitam-hitamanan': 'hitam',
'menghitamputihkan': 'hitam putih',
'menghitam-memutihkan': 'hitam putih',
'hitungan': 'hitung',
'hitungannya': 'hitung',
'hitungannyalah': 'hitung',
'hitunganku': 'hitung',
'terhitung': 'hitung',
'terhitungnya': 'hitung',
'terhitunglah': 'hitung',
'terhitungkan': 'hitung',
'terhitungan': 'hitung',
'berhitung': 'hitung',
'berhitungnya': 'hitung',
'menghitung': 'hitung',
'menghitungnya': 'hitung',
'menghitungkan': 'hitung',
'menghitungi': 'hitung',
'menghitungan': 'hitung',
'perhitungan': 'hitung',
'perhitungannya': 'hitung',
'perhitunganku': 'hitung',
'perhitunganmu': 'hitung',
'penghitungan': 'hitung',
'penghitungannya': 'hitung',
'hitung-hitung': 'hitung',
'hitung-hitungnya': 'hitung',
'hitung-hitungan': 'hitung',
'hitung-hitungannya': 'hitung',
'hitung-hitunganan': 'hitung',
'memperhitungkan': 'hitung',
'memperhitungkannya': 'hitung',
'memperhitungkanku': 'hitung',
'menghitung-hitung': 'hitung',
'menghitung-hitungnya': 'hitung',
'penghobi': 'hobi',
'penghobinya': 'hobi',
'berhoki': 'hoki',
'menghomoi': 'homo',
'kehomofonan': 'homofon',
'kehomogenan': 'homogen',
'kehomografan': 'homograf',
'kehomoniman': 'homonim',
'menghonori': 'honor',
'perhotelan': 'hotel',
'perhotelannya': 'hotel',
'berhujah': 'hujah',
'menghujananginkan': 'hujan angin',
'berhujan': 'hujan',
'kehujanan': 'hujan',
'kehujananan': 'hujan',
'menghujan': 'hujan',
'menghujankan': 'hujan',
'menghujani': 'hujan',
'menghujaninya': 'hujan',
'menghujaniku': 'hujan',
'memperhujankan': 'hujan',
'berhujan-hujan': 'hujan',
'berhujan-hujanan': 'hujan',
'menghujan-hujankan': 'hujan',
'menghujanpanaskan': 'hujan panas',
'hujatan': 'hujat',
'hujatannya': 'hujat',
'hujatanmu': 'hujat',
'menghujat': 'hujat',
'menghujatnya': 'hujat',
'penghujat': 'hujat',
'penghujatnya': 'hujat',
'penghujatan': 'hujat',
'penghujung': 'hujung',
'penghujungnya': 'hujung',
'kehujungan': 'hujung',
'hukuman': 'hukum',
'hukumannya': 'hukum',
'hukumanan': 'hukum',
'hukumanku': 'hukum',
'hukumanmu': 'hukum',
'hukuman-mu': 'hukum',
'berhukum': 'hukum',
'terhukum': 'hukum',
'terhukumnya': 'hukum',
'menghukum': 'hukum',
'menghukumnya': 'hukum',
'menghukumi': 'hukum',
'menghukuman': 'hukum',
'menghukumku': 'hukum',
'menghukummu': 'hukum',
'kehukuman': 'hukum',
'menghukumkan': 'hukum',
'berhulu': 'hulu',
'menghulu': 'hulu',
'penghuluan': 'hulu',
'berhulukan': 'hulu',
'menghulukan': 'hulu',
'berhuma': 'huma',
'perhumaan': 'huma',
'memperhuma': 'huma',
'dihumasi': 'humas',
'kehumasan': 'humas',
'kehumasannya': 'humas',
'perhumasan': 'humas',
'terhunjam': 'hunjam',
'menghunjam': 'hunjam',
'menghunjamnya': 'hunjam',
'menghunjamkan': 'hunjam',
'menghunjamkannya': 'hunjam',
'menghunjami': 'hunjam',
'terhunus': 'hunus',
'terhunusnya': 'hunus',
'menghunus': 'hunus',
'menghunuskan': 'hunus',
'menghunuskannya': 'hunus',
'berhura-hura': 'hura-hura',
'berhuruf': 'huruf',
'menghutan': 'hutan',
'menghutankan': 'hutan',
'menghutani': 'hutan',
'kehutanan': 'hutan',
'kehutanannya': 'hutan',
'kehutananlah': 'hutan',
'kehutananan': 'hutan',
'perhutanan': 'hutan',
'penghutanan': 'hutan',
'terhuyung': 'huyung',
'seia': 'ia',
'seiaku': 'ia',
'beria': 'ria',
'beriakan': 'riak',
'beriaku': 'ria',
'beria-ia': 'ia',
'mengiakan': 'ia',
'mengiakannya': 'ia',
'pengiba': 'iba',
'keibaan': 'iba',
'keibaannya': 'iba',
'mengibai': 'iba',
'mengibakan': 'iba',
'beriba-iba': 'iba',
'beribadah': 'ibadah',
'beribadahnya': 'ibadah',
'peribadahan': 'ibadah',
'peribadahannya': 'ibadah',
'beribadat': 'ibadat',
'beribadatan': 'ibadat',
'peribadatan': 'ibadat',
'peribadatannya': 'ibadat',
'beribarat': 'ibarat',
'pengibaratan': 'ibarat',
'mengibaratkan': 'ibarat',
'mengibaratkannya': 'ibarat',
'mengibing': 'ibing',
'mengibrit': 'ibrit',
'beribu': 'ibu',
'beribukan': 'ibu',
'keibuan': 'ibu',
'keibuannya': 'ibu',
'mengicip': 'icip',
'mengicipi': 'icip',
'mengidah': 'idah',
'mengidahkan': 'idah',
'idaman': 'idam',
'idamannya': 'idam',
'idamanku': 'idam',
'idamanmu': 'idam',
'mengidam': 'idam',
'mengidamnya': 'idam',
'mengidamkan': 'idam',
'mengidamkannya': 'idam',
'idam-idam': 'idam',
'idam-idamkan': 'idam',
'idam-idamkannya': 'idam',
'idam-idaman': 'idam',
'mengidam-idamkan': 'idam',
'mengidam-idamkannya': 'idam',
'idapan': 'idap',
'pengidap': 'idap',
'pengidapnya': 'idap',
'pengidapan': 'idap',
'mengidap': 'idap',
'mengidapnya': 'idap',
'mengidapkan': 'idap',
'seidas': 'idas',
'mengidas': 'idas',
'mengidealkan': 'ideal',
'mengidealisasikan': 'idealisasi',
'mengidentifikasi': 'identifikasi',
'mengidentifikasinya': 'identifikasi',
'mengidentifikasikan': 'identifikasi',
'mengidentifikasikannya': 'identifikasi',
'mengidentifikasii': 'identifikasi',
'mengidentikkan': 'identik',
'mengidentikkannya': 'identik',
'beridentitas': 'identitas',
'beridentitaskan': 'identitas',
'berideologi': 'ideologi',
'berideologikan': 'ideologi',
'pengidolaan': 'idola',
'mengidolakan': 'idola',
'mengidolakannya': 'idola',
'mengidolakanmu': 'idola',
'periduan': 'ridu',
'mengigal': 'igal',
'igauan': 'igau',
'igauannya': 'igau',
'terigau': 'igau',
'mengigau': 'igau',
'mengigaunya': 'igau',
'pengigau': 'igau',
'mengigaukan': 'igau',
'igau-igauan': 'igau',
'terigau-igau': 'igau',
'berihram': 'ihram',
'mengihtimalkan': 'ihtimal',
'berijab': 'ijab',
'mengijabkan': 'ijab',
'berijazah': 'ijazah',
'berijazahkan': 'ijazah',
'berijmak': 'ijmak',
'mengijmalkan': 'ijmal',
'pengijon': 'ijon',
'pengijonan': 'ijon',
'berijtihad': 'ijtihad',
'terijuk': 'ijuk',
'mengijuk': 'ijuk',
'ikalan': 'ikal',
'mengikal': 'ikal',
'ikanan': 'ikan',
'berikan': 'ikan',
'berikannya': 'ikan',
'berikanlah': 'ikan',
'berikanan': 'ikan',
'berikanku': 'ikan',
'pengikan': 'ikan',
'perikanan': 'ikan',
'perikanannya': 'ikan',
'perikananan': 'ikan',
'ikatan': 'ikat',
'ikatannya': 'ikat',
'ikatanmu': 'ikat',
'terikat': 'ikat',
'terikatnya': 'ikat',
'terikati': 'ikat',
'terikatan': 'ikat',
'berikat': 'ikat',
'berikatnya': 'ikat',
'berikatan': 'ikat',
'pengikat': 'ikat',
'pengikatnya': 'ikat',
'pengikatan': 'ikat',
'pengikatmu': 'ikat',
'mengikat': 'ikat',
'mengikatnya': 'ikat',
'mengikatkan': 'ikat',
'mengikatkannya': 'ikat',
'mengikatku': 'ikat',
'mengikatmu': 'ikat',
'perikatan': 'ikat',
'perikatannya': 'ikat',
'keterikatan': 'ikat',
'keterikatannya': 'ikat',
'keikhlasan': 'ikhlas',
'keikhlasannya': 'ikhlas',
'keikhlasanmu': 'ikhlas',
'mengikhlaskan': 'ikhlas',
'mengikhlaskannya': 'ikhlas',
'mengikhtisarkan': 'ikhtisar',
'seikhwan': 'ikhwan',
'pengiklan': 'iklan',
'pengiklannya': 'iklan',
'pengiklanan': 'iklan',
'periklanan': 'iklan',
'periklanannya': 'iklan',
'pengiklanannya': 'iklan',
'mengiklankan': 'iklan',
'mengiklankannya': 'iklan',
'beriklim': 'iklim',
'keikliman': 'iklim',
'beriktikad': 'iktikad',
'mengiktikadkan': 'iktikad',
'keikutsertaan': 'ikut serta',
'keikutsertaannya': 'ikut serta',
'keikutsertaanku': 'ikut serta',
'pengikutsertaan': 'ikut serta',
'mengikutsertakan': 'ikut serta',
'mengikutsertakannya': 'ikut serta',
'berilah': 'ilah',
'keilahan': 'ilah',
'keilahian': 'ilahi',
'mengilai': 'ilai',
'mengilai-ilai': 'ilai',
'mengilar': 'ilar',
'mengilas': 'kilas',
'mengiler': 'iler',
'mengiles': 'iles',
'mengilhami': 'ilham',
'mengilhaminya': 'ilham',
'mengilhamiku': 'ilham',
'pengilhaman': 'ilham',
'mengilhamkan': 'ilham',
'mengili': 'kili',
'ilingan': 'iling',
'mengiling': 'iling',
'mengilingi': 'iling',
'pengilingan': 'iling',
'mengilmiahkan': 'ilmiah',
'berilmu': 'ilmu',
'keilmuan': 'ilmu',
'keilmuannya': 'ilmu',
'keilmuanan': 'ilmu',
'mengilmukan': 'ilmu',
'mengilustrasikan': 'ilustrasi',
'mengilustrasikannya': 'ilustrasi',
'mengimak': 'imak',
'mengimak-imak': 'imak',
'keimaman': 'imam',
'keimamannya': 'imam',
'mengimami': 'imam',
'mengimbak-imbak': 'imbak',
'imbalan': 'imbal',
'imbalannya': 'imbal',
'imbalani': 'imbal',
'pengimbal': 'imbal',
'mengimbal': 'imbal',
'mengimbali': 'imbal',
'pengimbalan': 'imbal',
'mengimbalkan': 'imbal',
'imbangan': 'imbang',
'imbangannya': 'imbang',
'seimbang': 'imbang',
'seimbangnya': 'imbang',
'seimbanglah': 'imbang',
'seimbangkan': 'imbang',
'seimbangi': 'imbang',
'seimbangan': 'imbang',
'berimbang': 'imbang',
'berimbangnya': 'imbang',
'berimbanglah': 'imbang',
'berimbangan': 'imbang',
'mengimbang': 'imbang',
'mengimbangkan': 'imbang',
'mengimbangi': 'imbang',
'keimbangan': 'imbang',
'pengimbang': 'imbang',
'pengimbangnya': 'imbang',
'pengimbangi': 'imbang',
'pengimbangan': 'imbang',
'perimbangan': 'imbang',
'perimbangannya': 'imbang',
'mengimbanginya': 'imbang',
'mengimbangiku': 'imbang',
'keseimbangan': 'imbang',
'keseimbangannya': 'imbang',
'keseimbanganlah': 'imbang',
'keseimbanganmu': 'imbang',
'memperimbang': 'imbang',
'memperimbangkan': 'imbang',
'memperimbangan': 'imbang',
'menyeimbangkan': 'imbang',
'menyeimbangkannya': 'imbang',
'imbang-imbangan': 'imbang',
'memperseimbangkan': 'imbang',
'terimbas': 'imbas',
'terimbasnya': 'imbas',
'terimbasi': 'imbas',
'berimbas': 'imbas',
'berimbasnya': 'imbas',
'mengimbas': 'imbas',
'mengimbasi': 'imbas',
'imbauan': 'imbau',
'imbauannya': 'imbau',
'imbauanlah': 'imbau',
'terimbau': 'imbau',
'mengimbau': 'imbau',
'mengimbaunya': 'imbau',
'mengimbaukan': 'imbau',
'mengimbaui': 'imbau',
'mengimbauan': 'imbau',
'pengimbauan': 'imbau',
'mengimbit': 'imbit',
'imbuhan': 'imbuh',
'mengimbuh': 'imbuh',
'mengimbuhkan': 'imbuh',
'mengimbuhi': 'imbuh',
'mengimbuhinya': 'imbuh',
'mengiming-iming': 'iming-iming',
'mengiming-imingnya': 'iming-iming',
'mengiming-imingkan': 'iming-iming',
'mengiming-imingi': 'iming-iming',
'mengiming-imingan': 'iming-iming',
'mengimitasi': 'imitasi',
'mengimitasinya': 'imitasi',
'mengimkan': 'imkan',
'mengimlakan': 'imla',
'mengimpas': 'impas',
'mengimpaskan': 'impas',
'impian': 'impi',
'impiannya': 'impi',
'impianku': 'impi',
'impianmu': 'impi',
'mengimpikan': 'impi',
'mengimpikannya': 'impi',
'terimpi-impi': 'impi',
'impitan': 'impit',
'berimpit': 'impit',
'berimpitan': 'impit',
'terimpit': 'impit',
'mengimpit': 'impit',
'mengimpitnya': 'impit',
'memperimpit': 'impit',
'mengimpitkan': 'impit',
'berimpit-impit': 'impit',
'berimpit-impitan': 'impit',
'memperimpit-impitkan': 'impit',
'mengimplementasikan': 'implementasi',
'mengimplementasikannya': 'implementasi',
'berimplikasi': 'implikasi',
'terimplikasi': 'implikasi',
'mengimplikasikan': 'implikasi',
'mengimplisitkan': 'implisit',
'mengimpor': 'impor',
'mengimpornya': 'impor',
'pengimpor': 'impor',
'pengimpornya': 'impor',
'pengimporan': 'impor',
'berimprovisasi': 'improvisasi',
'berimprovisasinya': 'improvisasi',
'mengimprovisasikan': 'improvisasi',
'keimunan': 'imun',
'pengimunan': 'imun',
'berinai': 'inai',
'menginai': 'inai',
'menginang': 'kinang',
'inang-inang': 'inang',
'menginap': 'inap',
'menginapnya': 'inap',
'menginaplah': 'inap',
'menginapkan': 'inap',
'menginapkannya': 'inap',
'menginapan': 'inap',
'penginapan': 'inap',
'penginapannya': 'inap',
'penginapanan': 'inap',
'inca-binca': 'inca',
'incaran': 'incar',
'incarannya': 'incar',
'incaranku': 'incar',
'incaranmu': 'incar',
'mengincar': 'incar',
'mengincarnya': 'incar',
'mengincarkan': 'incar',
'mengincarkannya': 'incar',
'mengincari': 'incar',
'mengincarku': 'incar',
'mengincarmu': 'incar',
'terincit': 'incit',
'mengincitkan': 'incit',
'mengincrit-incrit': 'incrit',
'terincut-incut': 'incut',
'terindah': 'indah',
'terindahnya': 'indah',
'terindahku': 'indah',
'keindahan': 'indah',
'keindahannya': 'indah',
'keindahanmu': 'indah',
'pengindah': 'indah',
'pengindahan': 'indah',
'memperindah': 'indah',
'memperindahnya': 'indah',
'mengindahkan': 'indah',
'mengindahkannya': 'indah',
'terindang': 'indang',
'mengindang': 'indang',
'berindap-indap': 'indap',
'mengindekoskan': 'indekos',
'mengindik': 'indik',
'berindikasi': 'indikasi',
'berindikasikan': 'indikasi',
'mengindikasikan': 'indikasi',
'mengindikasikannya': 'indikasi',
'menginding': 'inding',
'mengindoktrinasi': 'indoktrinasi',
'keindonesiaan': 'indonesia',
'keindonesiaannya': 'indonesia',
'pengindonesiaan': 'indonesia',
'mengindonesiakan': 'indonesia',
'pengindra': 'indra',
'pengindranya': 'indra',
'pengindraan': 'indra',
'mengindra': 'indra',
'keindraan': 'indra',
'perinduan': 'indu',
'seperinduan': 'indu',
'berinduk': 'induk',
'berindukkan': 'induk',
'berinduki': 'induk',
'menginduk': 'induk',
'menginduki': 'induk',
'keindukan': 'induk',
'seperinduk': 'induk',
'menginduksi': 'induksi',
'menginduksikan': 'induksi',
'perindustrian': 'industri',
'perindustriannya': 'industri',
'mengindustrikan': 'industri',
'inefisiensi': 'inefisien',
'inefisiensinya': 'inefisien',
'menginfakkan': 'infak',
'menginfakkannya': 'infak',
'terinfeksi': 'infeksi',
'terinfeksinya': 'infeksi',
'menginfeksi': 'infeksi',
'menginfeksinya': 'infeksi',
'menginfeksikan': 'infeksi',
'berinfiltrasi': 'infiltrasi',
'menginfiltrasi': 'infiltrasi',
'menginfiltrasikan': 'infiltrasi',
'berinfleksi': 'infleksi',
'menginformasikan': 'informasi',
'menginformasikannya': 'informasi',
'menginformasikankan': 'informasi',
'menginformasikanku': 'informasi',
'menginfus': 'infus',
'teringa-inga': 'inga',
'mengingari': 'ingar',
'ingar-ingar': 'ingar',
'mengingarkan': 'ingar',
'ingar-bingar': 'ingar',
'ingar-bingarnya': 'ingar',
'ingatan': 'ingat',
'ingatannya': 'ingat',
'ingatanku': 'ingat',
'seingat': 'ingat',
'seingatnya': 'ingat',
'seingatku': 'ingat',
'beringat': 'ingat',
'teringat': 'ingat',
'teringatlah': 'ingat',
'mengingat': 'ingat',
'mengingatnya': 'ingat',
'mengingatkan': 'ingat',
'mengingatkannya': 'ingat',
'mengingati': 'ingat',
'mengingatan': 'ingat',
'mengingatku': 'ingat',
'mengingatmu': 'ingat',
'mengingat-ku': 'ingat',
'peringatan': 'ingat',
'peringatannya': 'ingat',
'peringatani': 'ingat',
'peringatanan': 'ingat',
'mengingatinya': 'ingat',
'ingat-ingat': 'ingat',
'ingat-ingatlah': 'ingat',
'memperingati': 'ingat',
'memperingatinya': 'ingat',
'memperingatikan': 'ingat',
'memperingatian': 'ingat',
'mengingatkanlah': 'ingat',
'mengingatkankan': 'ingat',
'mengingatkanku': 'ingat',
'mengingatkanmu': 'ingat',
'ingat-ingatan': 'ingat',
'memperingatkan': 'ingat',
'memperingatkannya': 'ingat',
'memperingatkankan': 'ingat',
'memperingatkanku': 'ingat',
'memperingatkanmu': 'ingat',
'beringat-ingat': 'ingat',
'teringat-ingat': 'ingat',
'mengingat-ingat': 'ingatan',
'mengingat-ingatnya': 'ingatan',
'mengingat-ingatkan': 'ingatan',
'mengingau': 'ingau',
'mengingaukan': 'ingau',
'ingau-ingauan': 'ingau',
'menginggriskan': 'inggris',
'keinggris-inggrisan': 'inggris',
'keinginan': 'ingin',
'keinginannya': 'ingin',
'keinginanan': 'ingin',
'keinginanku': 'ingin',
'keinginanmu': 'ingin',
'mengingini': 'ingin',
'memperingin': 'ingin',
'berkeinginan': 'ingin',
'berkeinginannya': 'ingin',
'menginginkan': 'ingin',
'menginginkannya': 'ingin',
'menginginkankan': 'ingin',
'menginginkanku': 'ingin',
'menginginkanmu': 'ingin',
'keingintahuan': 'ingin tahu',
'keingintahuannya': 'ingin tahu',
'keingintahuanku': 'ingin tahu',
'keingkaran': 'ingkar',
'keingkarannya': 'ingkar',
'mengingkari': 'ingkar',
'mengingkarinya': 'ingkar',
'pengingkaran': 'ingkar',
'mengingsar': 'ingsar',
'ingsutan': 'ingsut',
'beringsut': 'ingsut',
'beringsutnya': 'ingsut',
'mengingsut': 'ingsut',
'mengingsutkan': 'ingsut',
'ingusan': 'ingus',
'mengingusi': 'ingus',
'berinisial': 'inisial',
'berinisialnya': 'inisial',
'berinisialkan': 'inisial',
'menginisiasikan': 'inisiasi',
'menginisiasikannya': 'inisiasi',
'berinisiatif': 'inisiatif',
'berinisiatiflah': 'inisiatif',
'injakan': 'injak',
'injakannya': 'injak',
'terinjak': 'injak',
'terinjaknya': 'injak',
'menginjak': 'injak',
'menginjaknya': 'injak',
'menginjakkan': 'injak',
'menginjaki': 'injak',
'menginjakan': 'injak',
'injak-injak': 'injak',
'injak-injaklah': 'injak',
'injak-injakan': 'injak',
'terinjak-injak': 'injak',
'terinjak-injaknya': 'injak',
'menginjak-injak': 'injak',
'menginjak-injaknya': 'injak',
'menginjak-injakkan': 'injak',
'menginjap': 'injap',
'menginjeksi': 'injeksi',
'menginjeksinya': 'injeksi',
'menginjeksikan': 'injeksi',
'menginjil': 'injil',
'menginjili': 'injil',
'penginjil': 'injil',
'penginjilan': 'injil',
'penginjilannya': 'injil',
'berinkarnasi': 'inkarnasi',
'menginkorporasikan': 'inkorporasi',
'menginovasikan': 'inovasi',
'keinsafan': 'insaf',
'menginsafi': 'insaf',
'menginsafkan': 'insaf',
'berinsang': 'insang',
'menginsinuasi': 'insinuasi',
'menginspeksi': 'inspeksi',
'menginspeksinya': 'inspeksi',
'menginspeksiku': 'inspeksi',
'terinspirasi': 'inspirasi',
'terinspirasinya': 'inspirasi',
'menginspirasi': 'inspirasi',
'menginspirasinya': 'inspirasi',
'menginspirasikan': 'inspirasi',
'menginspirasiku': 'inspirasi',
'menginspirasimu': 'inspirasi',
'menginstruksikan': 'instruksi',
'menginstruksikannya': 'instruksi',
'mengintai': 'intai',
'mengintainya': 'intai',
'mengintaian': 'intai',
'pengintai': 'intai',
'pengintainya': 'intai',
'pengintaian': 'intai',
'pengintaiannya': 'intai',
'mengintaikan': 'intai',
'pengintensifan': 'intensif',
'pengintensifannya': 'intensif',
'mengintensifkan': 'intensif',
'mengintensifkannya': 'intensif',
'pengintensifikasian': 'intensifikasi',
'menginterlokal': 'interlokal',
'menginternasional': 'internasional',
'menginternasionalkan': 'internasional',
'penginternasionalan': 'internasional',
'interniran': 'internir',
'menginternir': 'internir',
'menginternirnya': 'internir',
'menginterogasi': 'interogasi',
'menginterogasinya': 'interogasi',
'menginterogasiku': 'interogasi',
'penginterpretasi': 'interpretasi',
'penginterpretasian': 'interpretasi',
'menginterpretasikan': 'interpretasi',
'menginterpretasikannya': 'interpretasi',
'menginterupsi': 'interupsi',
'menginterupsinya': 'interupsi',
'terintervensi': 'intervensi',
'mengintervensi': 'intervensi',
'mengintervensinya': 'intervensi',
'menginterviu': 'interviu',
'penginti': 'inti',
'pengintian': 'inti',
'perintian': 'inti',
'keintiman': 'intim',
'keintimannya': 'intim',
'mengintimi': 'intim',
'mengintiminya': 'intim',
'mengintimidasi': 'intimidasi',
'mengintimidasinya': 'intimidasi',
'mengintimidasimu': 'intimidasi',
'mengintip': 'intip',
'mengintipnya': 'intip',
'mengintipkan': 'intip',
'mengintroduksi': 'introduksi',
'mengintroduksikan': 'introduksi',
'berintrospeksi': 'introspeksi',
'mengintrospeksi': 'introspeksi',
'mengintrospeksikan': 'introspeksi',
'terintrusi': 'intrusi',
'berinvasi': 'invasi',
'menginvasi': 'invasi',
'menginvasinya': 'invasi',
'menginventarisasi': 'inventarisasi',
'menginventarisasinya': 'inventarisasi',
'menginventarisasikan': 'inventarisasi',
'berinvestasi': 'investasi',
'berinvestasinya': 'investasi',
'berinvestasilah': 'investasi',
'berinvestasikan': 'investasi',
'menginvestasikan': 'investasi',
'menginvestasikannya': 'investasi',
'terion': 'ion',
'terionkan': 'ion',
'pengionan': 'ion',
'mengionkan': 'ion',
'terionisasi': 'ionisasi',
'beripar': 'ipar',
'mengiprit': 'iprit',
'beripuh': 'ipuh',
'ipukan': 'ipuk',
'mengipuk': 'ipuk',
'pengipukan': 'ipuk',
'seiras': 'iras',
'irasan': 'iras',
'mengiras': 'iras',
'iras-iras': 'iras',
'mengiras-iras': 'iras',
'mengiras-irasi': 'iras',
'keirihatian': 'iri hati',
'mengiri': 'kiri',
'mengirinya': 'kiri',
'mengirikan': 'kirik',
'mengirikannya': 'kiri',
'mengirimu': 'kiri',
'keirian': 'iri',
'keiriannya': 'iri',
'pengiri': 'iri',
'pengirinya': 'iri',
'pengirian': 'iri',
'pengirik': 'irik',
'mengirik': 'kirik',
'seiring': 'iring',
'seiringnya': 'iring',
'seiringi': 'iring',
'seiringan': 'iring',
'iringan': 'iring',
'iringannya': 'iring',
'beriring': 'iring',
'beriringnya': 'iring',
'beriringan': 'iring',
'mengiring': 'iring',
'mengiringnya': 'iring',
'mengiringkan': 'iring',
'mengiringi': 'iring',
'mengiringan': 'iring',
'pengiring': 'iring',
'pengiringnya': 'iring',
'pengiringi': 'iring',
'pengiringan': 'iring',
'mengiringinya': 'iring',
'mengiringinyalah': 'iring',
'mengiringimu': 'iring',
'diiringkan': 'iring',
'iring-iringan': 'iring',
'iring-iringannya': 'iring',
'beriring-iring': 'iring',
'beriring-iringan': 'iring',
'irisan': 'iris',
'irisannya': 'iris',
'mengiris': 'iris',
'mengirisnya': 'iris',
'iris-irisan': 'iris',
'mengiriskan': 'iris',
'mengiris-iris': 'iris',
'mengiris-irisnya': 'iris',
'mengiris-iriskan': 'iris',
'mengirit': 'irit',
'mengiritnya': 'irit',
'mengiritkan': 'irit',
'pengiritan': 'irit',
'pengiritannya': 'irit',
'terisak-isak': 'isak',
'isapan': 'isap',
'isapannya': 'isap',
'mengisap': 'isap',
'mengisapnya': 'isap',
'pengisap': 'isap',
'pengisapnya': 'isap',
'pengisapan': 'isap',
'mengisapkan': 'isap',
'mengisbatkan': 'isbat',
'mengisengi': 'iseng',
'mengisenginya': 'iseng',
'iseng-iseng': 'iseng',
'iseng-isengnya': 'iseng',
'iseng-isengan': 'iseng',
'mengislahkan': 'islah',
'keislaman': 'islam',
'keislamannya': 'islam',
'keislamanan': 'islam',
'keislamanku': 'islam',
'pengislaman': 'islam',
'mengislamkan': 'islam',
'terisolasi': 'isolasi',
'terisolasinya': 'isolasi',
'pengisolasi': 'isolasi',
'pengisolasian': 'isolasi',
'mengisolasi': 'isolasi',
'mengisolasinya': 'isolasi',
'mengisolasikan': 'isolasi',
'pengisolasiannya': 'isolasi',
'mengistiadatkan': 'istiadat',
'beristibdad': 'istibdad',
'beristigfar': 'istigfar',
'beristikharah': 'istikharah',
'mengistikmalkan': 'istikmal',
'peristilahan': 'istilah',
'pengistilahan': 'istilah',
'mengistilahkan': 'istilah',
'mengistilahkannya': 'istilah',
'teristimewa': 'istimewa',
'teristimewanya': 'istimewa',
'teristimewaku': 'istimewa',
'keistimewaan': 'istimewa',
'keistimewaannya': 'istimewa',
'mengistimewakan': 'istimewa',
'mengistimewakannya': 'istimewa',
'beristinja': 'istinja',
'beristirahat': 'istirahat',
'beristirahatnya': 'istirahat',
'beristirahatlah': 'istirahat',
'peristirahatan': 'istirahat',
'peristirahatannya': 'istirahat',
'peristirahatanmu': 'istirahat',
'mengistirahatkan': 'istirahat',
'mengistirahatkannya': 'istirahat',
'beristri': 'istri',
'beristrikan': 'istri',
'memperistri': 'istri',
'memperistrinya': 'istri',
'memperistrikan': 'istri',
'mengisukan': 'isu',
'mengisyaratkan': 'isyarat',
'mengisyaratkannya': 'isyarat',
'itulah': 'itu',
'itulahnya': 'itu',
'itulahlah': 'itu',
'iuran': 'iur',
'iurannya': 'iur',
'iuranmu': 'iur',
'beriuran': 'iur',
'seizin': 'izin',
'seizinnya': 'izin',
'seizinkan': 'izin',
'seizini': 'izin',
'seizinmu': 'izin',
'keizinan': 'izin',
'perizinan': 'izin',
'perizinannya': 'izin',
'perizinanan': 'izin',
'perizinanku': 'izin',
'terizinkan': 'izin',
'mengizinkan': 'izin',
'mengizinkannya': 'izin',
'mengizinkankan': 'izin',
'mengizinkanku': 'izin',
'mengizinkanmu': 'izin',
'menjabal': 'jabal',
'penjabalan': 'jabal',
'jabaran': 'jabar',
'jabarannya': 'jabar',
'penjabaran': 'jabar',
'penjabarannya': 'jabar',
'menjabarkan': 'jabar',
'menjabarkannya': 'jabar',
'terjabarkan': 'jabar',
'sejabat': 'jabat',
'sejabatnya': 'jabat',
'pejabat': 'jabat',
'pejabatnya': 'jabat',
'pejabatlah': 'jabat',
'pejabati': 'jabat',
'pejabatan': 'jabat',
'pejabatku': 'jabat',
'jabatan': 'jabat',
'jabatannya': 'jabat',
'jabatani': 'jabat',
'jabatanku': 'jabat',
'jabatanmu': 'jabat',
'penjabat': 'jabat',
'penjabatnya': 'jabat',
'penjabatan': 'jabat',
'menjabat': 'jabat',
'menjabatnya': 'jabat',
'menjabatkan': 'jabat',
'menjabati': 'jabat',
'menjabatan': 'jabat',
'berjabat tangan': 'jabat tangan',
'berjabir-jabir': 'jabir',
'menjadi': 'jadi',
'menjadinya': 'jadi',
'menjadilah': 'jadi',
'menjadikan': 'jadi',
'menjadikannya': 'jadi',
'menjadii': 'jadi',
'menjadian': 'jadi',
'terjadi': 'jadi',
'terjadinya': 'jadi',
'terjadilah': 'jadi',
'terjadikan': 'jadi',
'terjadii': 'jadi',
'terjadian': 'jadi',
'penjadi': 'jadi',
'kejadian': 'jadi',
'kejadiannya': 'jadi',
'kejadianlah': 'jadi',
'kejadiani': 'jadi',
'kejadianan': 'jadi',
'penjadian': 'jadi',
'menjadikankan': 'jadi',
'menjadikanku': 'jadi',
'menjadikanmu': 'jadi',
'jadi-jadian': 'jadi',
'jadi-jadiannya': 'jadi',
'menjadi-jadi': 'jadi',
'menjadi-jadinya': 'jadi',
'sejadi-jadinya': 'jadi',
'menjadi-jadikan': 'jadi',
'terjadwal': 'jadwal',
'terjadwalnya': 'jadwal',
'terjadwalkan': 'jadwal',
'penjadwalan': 'jadwal',
'penjadwalannya': 'jadwal',
'menjadwalkan': 'jadwal',
'menjadwalkannya': 'jadwal',
'terjaga': 'jaga',
'terjaganya': 'jaga',
'terjagalah': 'jaga',
'penjaga': 'jaga',
'penjaganya': 'jaga',
'penjagaan': 'jaga',
'penjagaku': 'jaga',
'penjagamu': 'jaga',
'berjaga': 'jaga',
'berjaganya': 'jaga',
'berjagalah': 'jaga',
'berjagai': 'jaga',
'menjaga': 'jaga',
'menjaganya': 'jaga',
'menjagalah': 'jaga',
'menjagakan': 'jaga',
'menjagai': 'jaga',
'menjagaan': 'jaga',
'menjagaku': 'jaga',
'menjagamu': 'jaga',
'penjagaannya': 'jaga',
'berjaga-jaga': 'jaga',
'berjaga-jagalah': 'jaga',
'kejaga-jagaan': 'jaga',
'jagalan': 'jagal',
'berjagal': 'jagal',
'menjagal': 'jagal',
'menjagalnya': 'jagal',
'pejagalan': 'jagal',
'penjagalan': 'jagal',
'penjagalannya': 'jagal',
'sejagat': 'jagat',
'jagoan': 'jago',
'jagoannya': 'jago',
'jagoanku': 'jago',
'jagoanmu': 'jago',
'menjagoi': 'jago',
'menjagokan': 'jago',
'menjagokannya': 'jago',
'menjagung': 'jagung',
'berjagung-jagung': 'jagung',
'menjahanamkan': 'jahanam',
'menjahar': 'jahar',
'berjahat': 'jahat',
'penjahat': 'jahat',
'penjahatnya': 'jahat',
'menjahati': 'jahat',
'menjahatinya': 'jahat',
'kejahatan': 'jahat',
'kejahatannya': 'jahat',
'kejahatanlah': 'jahat',
'kejahatanan': 'jahat',
'kejahatanku': 'jahat',
'menjahatkan': 'jahat',
'menjahili': 'jahil',
'menjahilinya': 'jahil',
'kejahilan': 'jahil',
'kejahilannya': 'jahil',
'jahitan': 'jahit',
'jahitannya': 'jahit',
'menjahit': 'jahit',
'menjahitnya': 'jahit',
'menjahitkan': 'jahit',
'menjahitkannya': 'jahit',
'menjahiti': 'jahit',
'penjahit': 'jahit',
'penjahitnya': 'jahit',
'penjahitan': 'jahit',
'menjaili': 'jail',
'kejailan': 'jail',
'jaipongan': 'jaipong',
'berjaipong': 'jaipong',
'jajahan': 'jajah',
'jajahannya': 'jajah',
'menjajah': 'jajah',
'menjajahnya': 'jajah',
'menjajahkan': 'jajah',
'penjajah': 'jajah',
'penjajahnya': 'jajah',
'penjajahan': 'jajah',
'terjajah': 'jajah',
'terjajahnya': 'jajah',
'menjajahi': 'jajah',
'penjajahannya': 'jajah',
'penjajahanlah': 'jajah',
'menjajaki': 'jajak',
'menjajakinya': 'jajak',
'menjajal': 'jajal',
'menjajalnya': 'jajal',
'menjajalkan': 'jajal',
'menjajali': 'jajal',
'jajanan': 'jajan',
'jajanannya': 'jajan',
'jajananlah': 'jajan',
'jajananan': 'jajan',
'berjajan': 'jajan',
'kejaksaan': 'jaksa',
'kejaksaannya': 'jaksa',
'kejaksaanlah': 'jaksa',
'kejaksaannyalah': 'jaksa',
'penjala': 'jala',
'penjalaan': 'jala',
'menjala': 'jala',
'menjalakan': 'jala',
'menjalakannya': 'jala',
'menjalai': 'jala',
'terjala': 'jala',
'jala-jala': 'jala',
'jala-jalanya': 'jala',
'menjalakankan': 'jala',
'menjalang': 'jalang',
'menjalangi': 'jalang',
'kejalangan': 'jalang',
'menjalar': 'jalar',
'menjalarnya': 'jalar',
'menjalarkan': 'jalar',
'menjalari': 'jalar',
'berjalaran': 'jalar',
'penjalaran': 'jalar',
'penjalarannya': 'jalar',
'berjalar-jalar': 'jalar',
'terjali': 'jali',
'terjalinya': 'jali',
'menjalu': 'jalu',
'berjalur': 'jalur',
'berjalur-jalur': 'jalur',
'berjam-jam': 'jam',
'jamahan': 'jamah',
'menjamah': 'jamah',
'menjamahnya': 'jamah',
'menjamahi': 'jamah',
'menjamahku': 'jamah',
'terjamah': 'jamah',
'terjamahnya': 'jamah',
'terjamahkan': 'jamah',
'penjamah': 'jamah',
'penjamahan': 'jamah',
'jamah-jamahan': 'jamah',
'menjamak': 'jamak',
'kejamakan': 'jamak',
'sejamaknya': 'jamak',
'penjamakan': 'jamak',
'menjamakkan': 'jamak',
'sejambak': 'jambak',
'penjambak': 'jambak',
'penjambakan': 'jambak',
'menjambak': 'jambak',
'menjambaknya': 'jambak',
'menjambaki': 'jambak',
'jambak-jambakan': 'jambak',
'jambangan': 'jambang',
'sejambar': 'jambar',
'berjambar': 'jambar',
'jambatan': 'jambat',
'jambatannya': 'jambat',
'jambretan': 'jambret',
'jambretannya': 'jambret',
'menjambret': 'jambret',
'menjambretnya': 'jambret',
'penjambret': 'jambret',
'penjambretnya': 'jambret',
'penjambretan': 'jambret',
'penjambretannya': 'jambret',
'jambu-jambu': 'jambu',
'berjambul': 'jambul',
'jaminan': 'jamin',
'jaminannya': 'jamin',
'jaminanlah': 'jamin',
'jaminanan': 'jamin',
'penjamin': 'jamin',
'penjaminnya': 'jamin',
'penjaminan': 'jamin',
'terjamin': 'jamin',
'terjaminnya': 'jamin',
'terjaminan': 'jamin',
'menjamin': 'jamin',
'menjaminnya': 'jamin',
'menjaminlah': 'jamin',
'menjaminkan': 'jamin',
'menjaminkannya': 'jamin',
'menjaminan': 'jamin',
'menjaminku': 'jamin',
'penjaminannya': 'jamin',
'penjaminanan': 'jamin',
'keterjaminan': 'jaminan',
'jampian': 'jampi',
'berjampi': 'jampi',
'menjampi': 'jampi',
'jampi-jampi': 'jampi',
'jampi-jampinya': 'jampi',
'menjampikan': 'jampi',
'menjampuk': 'jampuk',
'berjamrah': 'jamrah',
'menjamur': 'jamur',
'menjamurnya': 'jamur',
'menjamurlah': 'jamur',
'menjamurkan': 'jamur',
'menjamuri': 'jamur',
'berjamur': 'jamur',
'berjamurnya': 'jamur',
'berjamurlah': 'jamur',
'berjamuran': 'jamur',
'menjanda': 'janda',
'penjangak': 'jangak',
'menjangak': 'jangak',
'jangankan': 'jangan',
'jangankankan': 'jangan',
'menjangankan': 'jangan',
'jangan-jangan': 'jangan',
'penjangat': 'jangat',
'menjangat': 'jangat',
'menjangati': 'jangat',
'kejanggalan': 'janggal',
'kejanggalannya': 'janggal',
'kejanggalanan': 'janggal',
'menjanggalkan': 'janggal',
'berjangka': 'jangka',
'berjangkanya': 'jangka',
'menjangka': 'jangka',
'menjangkakan': 'jangka',
'menjangkai': 'jangka',
'menjangkah': 'jangkah',
'menjangkang': 'jangkang',
'terjangkang': 'jangkang',
'menjangkar': 'jangkar',
'menjangkarkan': 'jangkar',
'jangkauan': 'jangkau',
'jangkauannya': 'jangkau',
'jangkauanku': 'jangkau',
'jangkauanmu': 'jangkau',
'menjangkau': 'jangkau',
'menjangkaunya': 'jangkau',
'menjangkauan': 'jangkau',
'terjangkau': 'jangkau',
'terjangkaunya': 'jangkau',
'terjangkaulah': 'jangkau',
'terjangkaui': 'jangkau',
'terjangkauan': 'jangkau',
'sejangkauan': 'jangkau',
'sepenjangkauan': 'jangkau',
'menjangki': 'jangki',
'jangkih mangkih': 'jangkih',
'jongkar-jangkir': 'jangkir',
'jangkungan': 'jangkung',
'menjangol': 'jangol',
'berjanguk': 'janguk',
'berjanjang': 'janjang',
'pejantan': 'jantan',
'pejantannya': 'jantan',
'pejantanan': 'jantan',
'berjantan': 'jantan',
'kejantanan': 'jantan',
'kejantanannya': 'jantan',
'kejantananmu': 'jantan',
'menjantani': 'jantan',
'perjantanan': 'jantan',
'terjantang': 'jantang',
'menjantang': 'jantang',
'berjantang': 'jantang',
'jantungan': 'jantung',
'berjantung': 'jantung',
'menjantung': 'jantung',
'terjantur': 'jantur',
'menjantur': 'jantur',
'menjara': 'jara',
'menjarai': 'jara',
'jarahan': 'jarah',
'jarahannya': 'jarah',
'penjarah': 'jarah',
'penjarahnya': 'jarah',
'penjarahan': 'jarah',
'menjarah': 'jarah',
'menjarahnya': 'jarah',
'menjarahi': 'jarah',
'menjarahan': 'jarah',
'penjarahannya': 'jarah',
'penjaram': 'jaram',
'berjaram': 'jaram',
'menjaram': 'jaram',
'menjarang': 'jarang',
'menjarangkan': 'jarang',
'penjarangan': 'jarang',
'memperjarang': 'jarang',
'jarang-jarang': 'jarang',
'jarang-jarangnya': 'jarang',
'jarang-jarangkan': 'jarang',
'sejaras': 'jaras',
'menjaras': 'jaras',
'menjari': 'jari',
'menjarikan': 'jari',
'penjarian': 'jari',
'jari-jari': 'jari',
'jari-jarinya': 'jari',
'jari-jariku': 'jari',
'berjari-jari': 'jari',
'jaringan': 'jaring',
'jaringannya': 'jaring',
'jaringanlah': 'jaring',
'jaringani': 'jaring',
'jaringanan': 'jaring',
'jaringanmu': 'jaring',
'menjaring': 'jaring',
'menjaringnya': 'jaring',
'menjaringkan': 'jaring',
'menjaringkannya': 'jaring',
'menjaringan': 'jaring',
'terjaring': 'jaring',
'terjaringnya': 'jaring',
'terjaringlah': 'jaring',
'terjaringan': 'jaring',
'jaring-jaring': 'jaring',
'jaring-jaringnya': 'jaring',
'jaring-jaringan': 'jaring',
'jaruman': 'jarum',
'menjarum': 'jarum',
'berjarum': 'jarum',
'jarum-jarum': 'jarum',
'pejasaboga': 'jasa boga',
'berjasa': 'jasa',
'berjasanya': 'jasa',
'berjasad': 'jasad',
'kejasmanian': 'jasmani',
'menjatah': 'jatah',
'menjatahnya': 'jatah',
'menjatahkan': 'jatah',
'menjatahi': 'jatah',
'penjatahan': 'jatah',
'penjatahannya': 'jatah',
'sejati': 'jati',
'sejatinya': 'jati',
'sejatilah': 'jati',
'sejatii': 'jati',
'sejatinyalah': 'jati',
'sejatiku': 'jati',
'sejatimu': 'jati',
'sejati-ku': 'jati',
'kesejatian': 'jati',
'kesejatiannya': 'jati',
'kejatmikaan': 'jatmika',
'jatuhan': 'jatuh',
'berjatuh': 'jatuh',
'berjatuhnya': 'jatuh',
'berjatuhkan': 'jatuh',
'berjatuhan': 'jatuh',
'terjatuh': 'jatuh',
'terjatuhnya': 'jatuh',
'terjatuhi': 'jatuh',
'kejatuhan': 'jatuh',
'kejatuhannya': 'jatuh',
'menjatuhi': 'jatuh',
'menjatuhinya': 'jatuh',
'berjatuhannya': 'jatuh',
'penjatuhan': 'jatuh',
'penjatuhannya': 'jatuh',
'menjatuhkan': 'jatuh',
'menjatuhkannya': 'jatuh',
'menjatuhkankan': 'jatuh',
'menjatuhkani': 'jatuh',
'menjatuhkanku': 'jatuh',
'menjatuhkanmu': 'jatuh',
'sejauh': 'jauh',
'sejauhnya': 'jauh',
'sejauhi': 'jauh',
'berjauh': 'jauh',
'berjauhan': 'jauh',
'menjauh': 'jauh',
'menjauhnya': 'jauh',
'menjauhlah': 'jauh',
'menjauhkan': 'jauh',
'menjauhkannya': 'jauh',
'menjauhi': 'jauh',
'kejauhan': 'jauh',
'menjauhinya': 'jauh',
'menjauhiku': 'jauh',
'menjauhkankan': 'jauh',
'menjauhkanmu': 'jauh',
'berjauh-jauhan': 'jauh',
'jawaban': 'jawab',
'jawabannya': 'jawab',
'jawabanlah': 'jawab',
'jawabankan': 'jawab',
'jawabanku': 'jawab',
'jawabanmu': 'jawab',
'menjawab': 'jawab',
'menjawabnya': 'jawab',
'menjawabi': 'jawab',
'menjawaban': 'jawab',
'berjawab': 'jawab',
'jawatan': 'jawat',
'sejawat': 'jawat',
'sejawatnya': 'jawat',
'menjawat': 'jawat',
'penjawat': 'jawat',
'berjawat': 'jawat',
'jawi-jawi': 'jawi',
'menjawikan': 'jawi',
'menjawil': 'jawil',
'berjebah': 'jebah',
'berjebai': 'jebai',
'jebakan': 'jebak',
'jebakannya': 'jebak',
'jebakanmu': 'jebak',
'penjebak': 'jebak',
'penjebaknya': 'jebak',
'penjebakkan': 'jebak',
'penjebakan': 'jebak',
'menjebak': 'jebak',
'menjebaknya': 'jebak',
'terjebak': 'jebak',
'terjebaknya': 'jebak',
'terjebaklah': 'jebak',
'terjebakan': 'jebak',
'penjebakannya': 'jebak',
'jebar-jebur': 'jebar',
'jebat-jebatan': 'jebat',
'terjeblok': 'jeblok',
'kejeblos': 'jeblos',
'terjeblos': 'jeblos',
'menjebloskan': 'jeblos',
'menjebloskannya': 'jeblos',
'menjebluk': 'jebluk',
'jebolan': 'jebol',
'jebolannya': 'jebol',
'menjebol': 'jebol',
'menjebolnya': 'jebol',
'menjebolkan': 'jebol',
'menjeboli': 'jebol',
'menjebrolkan': 'jebrol',
'menjebur': 'jebur',
'menjeburkan': 'jebur',
'menjedotkan': 'jedot',
'menjedotkannya': 'jedot',
'menjedot-jedotkan': 'jedot',
'menjegal': 'jegal',
'menjegalnya': 'jegal',
'jegal-jegalan': 'penjegalan',
'berjegal-jegalan': 'penjegalan',
'menjegil': 'jegil',
'terjegil': 'jegil',
'menjejak': 'jejak',
'menjejaknya': 'jejak',
'menjejakkan': 'jejak',
'menjejaki': 'jejak',
'menjejakan': 'jejak',
'berjejak': 'jejak',
'penjejak': 'jejak',
'penjejakkan': 'jejak',
'penjejakan': 'jejak',
'menjejakinya': 'jejak',
'menjejal': 'jejal',
'menjejalnya': 'jejal',
'menjejalkan': 'jejal',
'menjejalkannya': 'jejal',
'menjejali': 'jejal',
'berjejal': 'jejal',
'berjejalnya': 'jejal',
'berjejalan': 'jejal',
'menjejalinya': 'jejal',
'penjejalan': 'jejal',
'berjejal-jejal': 'jejal',
'berjejal-jejalan': 'jejal',
'jejeran': 'jejer',
'jejerannya': 'jejer',
'terjelabak': 'jelabak',
'berjelaga': 'jelaga',
'menjelajah': 'jelajah',
'menjelajahnya': 'jelajah',
'menjelajahkan': 'jelajah',
'menjelajahi': 'jelajah',
'penjelajah': 'jelajah',
'penjelajahnya': 'jelajah',
'penjelajahan': 'jelajah',
'menjelajahinya': 'jelajah',
'penjelajahannya': 'jelajah',
'terjelak': 'jelak',
'jelalatan': 'jelalat',
'menjelanak': 'jelanak',
'menjelang': 'jelang',
'menjelangnya': 'jelang',
'menjelangi': 'jelang',
'jelang-menjelang': 'jelang',
'menjelangak': 'jelangak',
'berjelapak': 'jelapak',
'terjelapak': 'jelapak',
'berjelapakan': 'jelapak',
'menjelar': 'jelar',
'penjelas': 'jelas',
'penjelasnya': 'jelas',
'penjelaskan': 'jelas',
'penjelasan': 'jelas',
'kejelasan': 'jelas',
'kejelasannya': 'jelas',
'kejelasanan': 'jelas',
'penjelasannya': 'jelas',
'penjelasanlah': 'jelas',
'penjelasanan': 'jelas',
'penjelasanku': 'jelas',
'memperjelas': 'jelas',
'memperjelasnya': 'jelas',
'memperjelaskan': 'jelas',
'terjelaskan': 'jelas',
'menjelaskan': 'jelas',
'menjelaskannya': 'jelas',
'menjelaskankan': 'jelas',
'menjelaskanan': 'jelas',
'menjelau': 'jelau',
'menjelejeh': 'jelejeh',
'berjelejehan': 'jelejeh',
'kejelekan': 'jelek',
'kejelekannya': 'jelek',
'menjelekkan': 'jelek',
'menjelekkannya': 'jelek',
'menjelek-jelekkan': 'jelek',
'menjelek-jelekkannya': 'jelek',
'menjelempah': 'jelempah',
'menjelengar': 'jelengar',
'terjelengar': 'jelengar',
'menjelepak': 'jelepak',
'menjelepok': 'jelepok',
'terjelepok': 'jelepok',
'kejelian': 'jeli',
'kejeliannya': 'jeli',
'menjelihkan': 'jelih',
'menjelijih': 'jelijih',
'menjelimet': 'jelimet',
'menjelimpat': 'jelimpat',
'menjeling': 'jeling',
'menjelirkan': 'jelir',
'menjelitkan': 'jelit',
'terjelma': 'jelma',
'menjelma': 'jelma',
'menjelmanya': 'jelma',
'menjelmakan': 'jelma',
'menjelmakannya': 'jelma',
'penjelmaan': 'jelma',
'penjelmaannya': 'jelma',
'menjeluak': 'jeluak',
'jelujuran': 'jelujur',
'menjelujur': 'jelujur',
'menjelujuri': 'jelujur',
'berjeluk': 'jeluk',
'berjelum': 'jelum',
'menjelum': 'jelum',
'menjelungkap': 'jelungkap',
'menjelunut': 'jelunut',
'kejelusan': 'jelus',
'menjeluskan': 'jelus',
'menjelut': 'jelut',
'berjemaah': 'jemaah',
'berjemaahnya': 'jemaah',
'menjemaahkan': 'jemaah',
'sejemang': 'jemang',
'kejemawaan': 'jemawa',
'jembaan': 'jemba',
'menjemba': 'jemba',
'menjembak': 'jembak',
'terjembak-jembak': 'jembak',
'terjembatani': 'jembatan',
'menjembatani': 'jembatan',
'menjembataninya': 'jembatan',
'penjembatanan': 'jembatan',
'jempalitan': 'jempalit',
'menjempalit': 'jempalit',
'berjempalitan': 'jempalit',
'jempolan': 'jempol',
'jempolannya': 'jempol',
'kejempolan': 'jempol',
'jemputan': 'jemput',
'jemputannya': 'jemput',
'sejemput': 'jemput',
'berjemput': 'jemput',
'menjemput': 'jemput',
'menjemputnya': 'jemput',
'menjemputku': 'jemput',
'menjemputmu': 'jemput',
'penjemput': 'jemput',
'penjemputnya': 'jemput',
'penjemputan': 'jemput',
'penjemputannya': 'jemput',
'jemuan': 'jemu',
'kejemuan': 'jemu',
'kejemuanmu': 'jemu',
'menjemukan': 'jemu',
'menjemukannya': 'jemu',
'sejenak': 'jenak',
'sejenaknya': 'jenak',
'menjenaki': 'jenak',
'jenangan': 'jenang',
'jejenang': 'jenang',
'sejenang': 'jenang',
'penjenang': 'jenang',
'penjenangan': 'jenang',
'menjenangi': 'jenang',
'jendal-jendul': 'jendal',
'jendelan': 'jendel',
'berjendul': 'jendul',
'menjenengkan': 'jeneng',
'jengekan': 'jengek',
'menjengek': 'jengek',
'menjengeki': 'jengek',
'menjengek-jengek': 'jengek',
'jenggar-jenggur': 'jenggar',
'jenggotan': 'jenggot',
'menjengguk': 'jengguk',
'menjenggut': 'jenggut',
'menjengit': 'jengit',
'menjengit-jengit': 'jengit',
'menjengkal': 'jengkal',
'menjengkalkan': 'jengkal',
'menjengkali': 'jengkal',
'menjengkang': 'jengkang',
'terjengkang': 'jengkang',
'terjengkangnya': 'jengkang',
'penjengkekan': 'jengkek',
'berjengkek-jengkek': 'jengkek',
'menjengkeli': 'jengkel',
'kejengkelan': 'jengkel',
'kejengkelannya': 'jengkel',
'menjengkelkan': 'jengkel',
'menjengkelkannya': 'jengkel',
'menjengkelit': 'jengkelit',
'berjengkeng': 'jengkeng',
'menjengkeng': 'jengkeng',
'berjengkengan': 'jengkeng',
'menjengking': 'jengking',
'menjengkit': 'jengkit',
'kejengkolan': 'jengkol',
'jengkoletan': 'jengkolet',
'menjengkolet': 'jengkolet',
'berjengkot': 'jengkot',
'menjengkot': 'jengkot',
'menjenguk': 'jenguk',
'menjenguknya': 'jenguk',
'menjengukku': 'jenguk',
'menjengukmu': 'jenguk',
'menjengukkan': 'jenguk',
'menjengul': 'jengul',
'sejenis': 'jenis',
'sejenisnya': 'jenis',
'sejenisnyalah': 'jenis',
'menjenis': 'jenis',
'penjenisan': 'jenis',
'berjenis-jenis': 'jenis',
'berjenjang': 'jenjang',
'berjenjang-jenjang': 'jenjang',
'berjentera': 'jentera',
'jentikan': 'jentik',
'menjentik': 'jentik',
'menjentikkan': 'jentik',
'menjentikkannya': 'jentik',
'menjentikan': 'jentik',
'kejenuhan': 'jenuh',
'kejenuhannya': 'jenuh',
'kejenuhanmu': 'jenuh',
'penjenuhan': 'jenuh',
'menjenuhkan': 'jenuh',
'menjenuhkannya': 'jenuh',
'menjepit': 'jepit',
'menjepitnya': 'jepit',
'menjepitkan': 'jepit',
'menjepitku': 'jepit',
'penjepit': 'jepit',
'penjepitnya': 'jepit',
'penjepitan': 'jepit',
'menjeprat': 'jeprat',
'jepretan': 'jepret',
'jepretannya': 'jepret',
'jepretanku': 'jepret',
'jepretanmu': 'jepret',
'menjepret': 'jepret',
'menjepretnya': 'jepret',
'menjepretkan': 'jepret',
'terjepret': 'jepret',
'penjepretan': 'jepret',
'penjepretannya': 'jepret',
'sejeput': 'jeput',
'menjeput': 'jeput',
'menjeputnya': 'jeput',
'menjerakan': 'jera',
'berjerabai': 'jerabai',
'jerah-jerih': 'jerah',
'terjerahak': 'jerahak',
'menjerahap': 'jerahap',
'terjerahap': 'jerahap',
'berjerait': 'jerait',
'berjeramah': 'jeramah',
'menjeramah': 'jeramah',
'menjerambah': 'jerambah',
'berjerambai': 'jerambai',
'terjerang': 'jerang',
'menjerang': 'jerang',
'menjerangkak': 'jerangkak',
'menjerangkang': 'jerangkang',
'terjerangkang': 'jerangkang',
'berjerangkang': 'jerangkang',
'menjerap': 'jerap',
'penjerapan': 'jerap',
'sejerat': 'jerat',
'terjerat': 'jerat',
'terjeratnya': 'jerat',
'menjerat': 'jerat',
'menjeratnya': 'jerat',
'menjeratkan': 'jerat',
'menjerauskan': 'jeraus',
'menjerba': 'jerba',
'menjerbak': 'jerbak',
'menjeremba': 'jeremba',
'terjerembap': 'jerembap',
'menjerembapkan': 'jerembap',
'terjerembat': 'jerembat',
'terjerembun': 'jerembun',
'menjerempak': 'jerempak',
'terjerempak': 'jerempak',
'berjerempak': 'jerempak',
'menjereng': 'jereng',
'menjeriau': 'jeriau',
'berjerih': 'jerih',
'kejerihan': 'jerih',
'menjerihkan': 'jerih',
'memperjerihkan': 'jerih',
'jeritan': 'jerit',
'jeritannya': 'jerit',
'menjerit': 'jerit',
'menjeritlah': 'jerit',
'menjeritkan': 'jerit',
'terjerit-jerit': 'jerit',
'menjerit-jerit': 'jerit',
'menjerkah': 'jerkah',
'berjermang': 'jermang',
'penjernih': 'jernih',
'penjernihnya': 'jernih',
'penjernihan': 'jernih',
'kejernihan': 'jernih',
'kejernihannya': 'jernih',
'penjernihannya': 'jernih',
'menjernihkan': 'jernih',
'menjernihkannya': 'jernih',
'terjerohok': 'jerohok',
'terjerojol': 'jerojol',
'menjerojol': 'jerojol',
'menjerongkok': 'jerongkok',
'menjerongkong': 'jerongkong',
'terjerongkong': 'jerongkong',
'menjeruki': 'jeruk',
'menjerukun': 'jerukun',
'menjerukup': 'jerukup',
'menjerum': 'jerum',
'berjerumat': 'jerumat',
'penjerumat': 'jerumat',
'menjerumat': 'jerumat',
'terjerumus': 'jerumus',
'terjerumusnya': 'jerumus',
'menjerumuskan': 'jerumus',
'menjerumuskannya': 'jerumus',
'menjerumuskanku': 'jerumus',
'menjerumuskanmu': 'jerumus',
'menjerungkau': 'jerungkau',
'menjerungkis': 'jerungkis',
'menjerungkung': 'jerungkung',
'terjerunuk': 'jerunuk',
'menjetis': 'jetis',
'jeweran': 'jewer',
'jewerannya': 'jewer',
'menjewer': 'jewer',
'menjewernya': 'jewer',
'berjibaku': 'jibaku',
'sejibun': 'jibun',
'berjibun': 'jibun',
'berjibunnya': 'jibun',
'menjidari': 'jidar',
'berjihad': 'jihad',
'berjihadlah': 'jihad',
'kejijikan': 'jijik',
'menjijikkan': 'jijik',
'menjijikkannya': 'jijik',
'menjijit': 'jijit',
'terjila': 'jila',
'menjilami': 'jilam',
'jilatan': 'jilat',
'jilatannya': 'jilat',
'menjilat': 'jilat',
'menjilatnya': 'jilat',
'menjilatkan': 'jilat',
'menjilatkannya': 'jilat',
'menjilati': 'jilat',
'penjilat': 'jilat',
'penjilatnya': 'jilat',
'penjilatan': 'jilat',
'menjilat-jilat': 'jilat',
'menjilat-jilati': 'jilat',
'penjilid': 'jilid',
'penjilidan': 'jilid',
'berjilid': 'jilid',
'menjilid': 'jilid',
'penjilidannya': 'jilid',
'berjilid-jilid': 'jilid',
'menjimak': 'jimak',
'berjimak': 'jimak',
'menjimbit': 'jimbit',
'jimpitan': 'jimpit',
'sejimpit': 'jimpit',
'menjimpit': 'jimpit',
'penjinak': 'jinak',
'penjinakkan': 'jinak',
'penjinakan': 'jinak',
'menjinaki': 'jinak',
'jinak-jinak': 'jinak',
'menjinakkan': 'jinak',
'menjinakkannya': 'jinak',
'berjinak-jinak': 'jinak',
'penjinayah': 'jinayah',
'menjingap': 'jingap',
'menjingau': 'jingau',
'kejingga-jinggaan': 'jingga',
'berjingkat': 'jingkat',
'berjingkat-jingkat': 'jingkat',
'berjingkik': 'jingkik',
'berjingkik-jingkik': 'jingkik',
'berjingkrak': 'jingkrak',
'berjingkraknya': 'jingkrak',
'berjingkrakkan': 'jingkrak',
'berjingkrakan': 'jingkrak',
'berjingkrak-jingkrak': 'jingkrak',
'menjingu': 'jingu',
'jinjangan': 'jinjang',
'berjinjang': 'jinjang',
'jinjingan': 'jinjing',
'terjinjing': 'jinjing',
'menjinjing': 'jinjing',
'menjinjingnya': 'jinjing',
'menjinjingkan': 'jinjing',
'berjinjit': 'jinjit',
'menjinjit': 'jinjit',
'menjinjitkan': 'jinjit',
'jiplakan': 'jiplak',
'jiplakannya': 'jiplak',
'menjiplak': 'jiplak',
'menjiplaknya': 'jiplak',
'penjiplakan': 'jiplak',
'dijiplakkan': 'jiplak',
'menjirus': 'jirus',
'menjitak': 'jitak',
'menjitaki': 'jitak',
'kejituan': 'jitu',
'kejituannya': 'jitu',
'menjitukan': 'jitu',
'berjiwa': 'jiwa',
'berjiwalah': 'jiwa',
'kejiwaan': 'jiwa',
'kejiwaannya': 'jiwa',
'menjiwai': 'jiwa',
'menjiwainya': 'jiwa',
'menjiwit': 'jiwit',
'berjobak': 'jobak',
'sejodoh': 'jodoh',
'penjodoh': 'jodoh',
'penjodohan': 'jodoh',
'berjodoh': 'jodoh',
'berjodohnya': 'jodoh',
'perjodohan': 'jodoh',
'perjodohannya': 'jodoh',
'menjodohkan': 'jodoh',
'menjodohkannya': 'jodoh',
'menjodohkanku': 'jodoh',
'menjodohkanmu': 'jodoh',
'memperjodohkan': 'jodoh',
'menjodongkan': 'jodong',
'berjogar': 'jogar',
'menjoget': 'joget',
'berjoget': 'joget',
'berjogetnya': 'joget',
'kejohanan': 'johan',
'menjojol': 'jojol',
'jolakan': 'jolak',
'menjolak': 'jolak',
'berjolak': 'jolak',
'menjolek': 'jolek',
'sejoli': 'joli',
'sejolinya': 'joli',
'joli-joli': 'joli',
'penjolok': 'jolok',
'menjolok': 'jolok',
'menjolong': 'jolong',
'jolong-jolong': 'jolong',
'menjolor': 'jolor',
'kejombangan': 'jombang',
'menjompak': 'jompak',
'berjompak': 'jompak',
'berjompakan': 'jompak',
'menjonget': 'jonget',
'jonggolan': 'jonggol',
'jonggol karang': 'jonggol',
'menjongkang': 'jongkang',
'jongkang-jangking': 'jongkang',
'berjongkok': 'jongkok',
'berjongkoklah': 'jongkok',
'berjongkok-jongkok': 'jongkok',
'selonjot': 'jonjot',
'menjonjot': 'jonjot',
'berjoran': 'joran',
'sejoreng': 'joreng',
'menjoreng': 'joreng',
'penjorok': 'jorok',
'menjorok': 'jorok',
'menjorokkan': 'jorok',
'kejorokan': 'jorok',
'kejorokannya': 'jorok',
'jotosan': 'jotos',
'jotosannya': 'jotos',
'menjotos': 'jotos',
'terjotos': 'jotos',
'berjotos': 'jotos',
'jotos-jotosan': 'jotos',
'berjuak': 'juak',
'berjuakan': 'juak',
'penjuak': 'juak',
'penjuaknya': 'juak',
'penjuakan': 'juak',
'menjuak': 'juak',
'juak-juak': 'juak',
'menjuakkan': 'juak',
'berjual beli': 'jual beli',
'menjualbelikan': 'jual beli',
'menjualbelikannya': 'jual beli',
'memperjualbelikan': 'jual beli',
'memperjualbelikannya': 'jual beli',
'menjuarai': 'juara',
'menjuarainya': 'juara',
'kejuaraan': 'juara',
'kejuaraannya': 'juara',
'kejuaraanlah': 'juara',
'berjubel': 'jubel',
'berjubelnya': 'jubel',
'berjubelan': 'jubel',
'menjubeli': 'jubel',
'berjubel-jubel': 'jubel',
'berjubel-jubelan': 'jubel',
'menjublek': 'jublek',
'pejudo': 'judo',
'berjudul': 'judul',
'berjudulkan': 'judul',
'menjujah': 'jujah',
'berjujai': 'jujai',
'menjuju': 'juju',
'kejujuran': 'jujur',
'kejujurannya': 'jujur',
'kejujuranlah': 'jujur',
'kejujuranmu': 'jujur',
'menjujuri': 'jujur',
'menjujut': 'jujut',
'berjujut-jujutan': 'jujut',
'berjulai': 'julai',
'terjulai': 'julai',
'menjulai': 'julai',
'berjulai-julai': 'julai',
'menjulang': 'julang',
'menjulangnya': 'julang',
'menjulangkan': 'julang',
'berjulat': 'julat',
'menjulat': 'julat',
'sepenjulat': 'julat',
'menjuling': 'juling',
'menjulingkan': 'juling',
'julo-julo': 'julo',
'julukan': 'juluk',
'julukannya': 'juluk',
'menjuluk': 'juluk',
'menjuluki': 'juluk',
'menjulukinya': 'juluk',
'penjulukan': 'juluk',
'julung asar': 'julung',
'julung-julung': 'julung',
'menjulur': 'julur',
'menjulurnya': 'julur',
'menjulurkan': 'julur',
'terjulur': 'julur',
'penjuluran': 'julur',
'julur-julur': 'julur',
'jumatan': 'jumat',
'berjumat': 'jumat',
'berjumatan': 'jumat',
'kejumbuhan': 'jumbuh',
'berjumbul-jumbul': 'jumbul',
'jumenengan': 'jumeneng',
'sejumlah': 'jumlah',
'sejumlahnya': 'jumlah',
'sejumlahkan': 'jumlah',
'sejumlahan': 'jumlah',
'menjumlah': 'jumlah',
'menjumlahkan': 'jumlah',
'menjumlahkannya': 'jumlah',
'terjumlah': 'jumlah',
'berjumlah': 'jumlah',
'berjumlahnya': 'jumlah',
'berjumlahkan': 'jumlah',
'penjumlahan': 'jumlah',
'berjumpa': 'jumpa',
'berjumpanya': 'jumpa',
'terjumpa': 'jumpa',
'menjumpai': 'jumpa',
'menjumpainya': 'jumpa',
'perjumpaan': 'jumpa',
'perjumpaannya': 'jumpa',
'jumpalitan': 'jumpalit',
'berjumpalit': 'jumpalit',
'berjumpalitan': 'jumpalit',
'jumputan': 'jumput',
'sejumput': 'jumput',
'menjumput': 'jumput',
'menjumputnya': 'jumput',
'menjumputi': 'jumput',
'kejumudan': 'jumud',
'menjunam': 'junam',
'terjunam': 'junam',
'sijundai': 'jundai',
'bersijundai': 'jundai',
'menjungat': 'jungat',
'terjungkal': 'jungkal',
'terjungkalnya': 'jungkal',
'menjungkalkan': 'jungkal',
'menjungkalkannya': 'jungkal',
'jungkang-jungkit': 'jungkang',
'menjungkar': 'jungkar',
'terjungkat': 'jungkat',
'jungkat-jungkit': 'jungkat',
'jungkat-jungkitnya': 'jungkat',
'menjungkat-jungkit': 'jungkat',
'berjungkir balik': 'jungkir balik',
'penjungkirbalikan': 'jungkir balik',
'menjungkirbalikkan': 'jungkir balik',
'menjungkirbalikkannya': 'jungkir balik',
'terjungkir': 'jungkir',
'terjungkirnya': 'jungkir',
'menjungkir': 'jungkir',
'menjungkirkan': 'jungkir',
'berjungkir': 'jungkir',
'menjungkit': 'jungkit',
'terjungkit': 'jungkit',
'menjungur': 'jungur',
'junjungan': 'junjung',
'junjungannya': 'junjung',
'junjunganku': 'junjung',
'menjunjung': 'junjung',
'menjunjungi': 'junjung',
'berjunjungan': 'junjung',
'menjunjungkan': 'junjung',
'juntrungan': 'juntrung',
'juntrungannya': 'juntrung',
'berjupang': 'jupang',
'menjura': 'jura',
'menjurai': 'jura',
'penjurian': 'juri',
'penjuriannya': 'juri',
'juringan': 'juring',
'menjurubicarai': 'juru bicara',
'menjuru': 'juru',
'penjuru': 'juru',
'penjurunya': 'juru',
'kejuruan': 'juru',
'kejuruannya': 'juru',
'jurusan': 'jurus',
'jurusannya': 'jurus',
'jurusanku': 'jurus',
'jurusanmu': 'jurus',
'sejurus': 'jurus',
'sejurusan': 'jurus',
'menjurus': 'jurus',
'menjurusnya': 'jurus',
'menjuruskan': 'jurus',
'penjurus': 'jurus',
'penjurusan': 'jurus',
'berjurus-jurus': 'jurus',
'menjustifikasikan': 'justifikasi',
'sejuta': 'juta',
'sejutanya': 'juta',
'sejutalah': 'juta',
'sejutaan': 'juta',
'jutaan': 'juta',
'jutaannya': 'juta',
'jutaanlah': 'juta',
'berjuta-juta': 'juta',
'berjuta-jutaan': 'juta',
'pengabar': 'kabar',
'pengabaran': 'kabar',
'berkabar': 'kabar',
'terkabar': 'kabar',
'terkabarnya': 'kabar',
'mengabarinya': 'kabar',
'mengabariku': 'kabar',
'perkabaran': 'kabar',
'mengabat': 'kabat',
'berkabilan': 'kabil',
'mengabir': 'kabir',
'kabir-kabiran': 'kabir',
'mengabit': 'kabit',
'kabruk-kabrukan': 'kabruk',
'berkabu-kabu': 'kabu-kabu',
'terkabul': 'kabul',
'terkabulnya': 'kabul',
'terkabulkan': 'kabul',
'terkabulkannya': 'kabul',
'pengabulan': 'kabul',
'pengabulannya': 'kabul',
'mengabulkan': 'kabul',
'mengabulkannya': 'kabul',
'mengabulkanmu': 'kabul',
'kekaburan': 'kabur',
'kekabur-kaburan': 'kabur',
'mengaca': 'kaca',
'mengacanya': 'kaca',
'berkaca': 'kaca',
'berkacalah': 'kaca',
'kekacaan': 'kaca',
'memperkaca': 'kaca',
'berkaca-kaca': 'kaca',
'pengacak': 'kacak',
'pengacakan': 'kacak',
'berkacak': 'kacak',
'berkacamata': 'kacamata',
'kacangan': 'kacang',
'mengacang': 'kacang',
'memperkacang': 'kacang',
'kacang-kacangan': 'kacang',
'kacang-kacangannya': 'kacang',
'mengacar': 'kacar',
'kacar lakum': 'kacar',
'kacauan': 'kacau',
'berkacau': 'kacau',
'terkacau': 'kacau',
'pengacau': 'kacau',
'pengacaunya': 'kacau',
'pengacauan': 'kacau',
'kekacauan': 'kacau',
'kekacauannya': 'kacau',
'mengacaukankannya': 'kacau',
'memperkacaukan': 'kacau',
'mengacaubalaukan': 'kacau-balau',
'mengacip': 'kacip',
'mengacir': 'kacir',
'mengada': 'kada',
'mengadaan': 'kada',
'dikadang': 'kadang',
'dikadangnya': 'kadang',
'dikadangkan': 'kadang',
'terkadang': 'kadang',
'terkadangkan': 'kadang',
'terkadangan': 'kadang',
'kadang-kadang': 'kadang',
'kadang-kadangnya': 'kadang',
'kadang-kadangkan': 'kadang',
'kadang-kadangan': 'kadang',
'terkadang-kadang': 'kadang',
'sekadar': 'kadar',
'sekadarnya': 'kadar',
'sekadari': 'kadar',
'mengadas': 'kadas',
'mengadaskan': 'kadas',
'mengadasi': 'kadas',
'pengaderan': 'kader',
'sekadim': 'kadim',
'mengadimkan': 'kadim',
'kadok api': 'kadok',
'berkafan': 'kafan',
'mengafani': 'kafan',
'kekafiran': 'kafir',
'kekafirannya': 'kafir',
'mengafirkan': 'kafir',
'mengafirkannya': 'kafir',
'kekagetan': 'kaget',
'kekagetannya': 'kaget',
'mengagetkan': 'kaget',
'mengagetkannya': 'kaget',
'mengagetkanku': 'kaget',
'pengagum': 'kagum',
'pengagumnya': 'kagum',
'mengagumi': 'kagum',
'mengaguminya': 'kagum',
'mengagumiku': 'kagum',
'mengagumimu': 'kagum',
'kekaguman': 'kagum',
'kekagumannya': 'kagum',
'kekagumanku': 'kagum',
'mengagumkan': 'kagum',
'mengagumkannya': 'kagum',
'terkagum-kagum': 'kagum',
'kekahatan': 'kahat',
'terkail': 'kail',
'mengail': 'kail',
'pengail': 'kail',
'pengailan': 'kail',
'kail-kail': 'kail',
'berkain': 'kain',
'berkaing-kaing': 'kaing',
'terkaing-kaing': 'kaing',
'mengais': 'kais',
'mengaisnya': 'kais',
'mengaiskan': 'kais',
'mengais-ngais': 'kais',
'kekaisaran': 'kaisar',
'kekaisarannya': 'kaisar',
'sekait': 'kait',
'sekaitan': 'kait',
'kaitan': 'kait',
'kaitannya': 'kait',
'pengait': 'kait',
'pengaitnya': 'kait',
'pengaitan': 'kait',
'mengait': 'kait',
'mengaitnya': 'kait',
'mengaitkan': 'kait',
'mengaitkannya': 'kait',
'mengaitan': 'kait',
'berkait': 'kait',
'berkaitkan': 'kait',
'berkaitan': 'kait',
'terkait': 'kait',
'terkaitnya': 'kait',
'terkaitlah': 'kait',
'terkaitkan': 'kait',
'terkaitan': 'kait',
'kait-kait': 'kait',
'kait-kaitkan': 'kait',
'kait-kaitan': 'kait',
'berkaitannya': 'kait',
'keterkaitan': 'kait',
'keterkaitannya': 'kait',
'berkait-kaitan': 'kait',
'berkajang': 'kajang',
'dikajangi': 'kajang',
'pekajangan': 'kajang',
'mengajangi': 'kajang',
'kajian': 'kaji',
'kajiannya': 'kaji',
'kajiani': 'kaji',
'terkaji': 'kaji',
'mengaji': 'kaji',
'mengajinya': 'kaji',
'mengajikan': 'kaji',
'mengkaji': 'kaji',
'mengkajinya': 'kaji',
'mengkajii': 'kaji',
'mengkajian': 'kaji',
'pengajian': 'kaji',
'pengajiannya': 'kaji',
'pengajiannyalah': 'kaji',
'pengkajian': 'kaji',
'pengkajiannya': 'kaji',
'terkakah-kakah': 'kakah',
'mengakak': 'kakak',
'mengakakan': 'kakak',
'berkakak': 'kakak',
'berkakakan': 'kakak',
'terkakak-kakak': 'kakak',
'mengakap': 'kakap',
'mengakapi': 'kakap',
'pengakap': 'kakap',
'pengakapan': 'kakap',
'mengakas': 'kakas',
'kakek-kakek': 'kakek',
'kakek-kakeknya': 'kakek',
'mengakok': 'kakok',
'kekakuan': 'kaku',
'kekakuannya': 'kaku',
'kekalahan': 'kalah',
'kekalahannya': 'kalah',
'kekalahanan': 'kalah',
'kekalahanku': 'kalah',
'kekalahanmu': 'kalah',
'terkalahkan': 'kalah',
'terkalahkannya': 'kalah',
'mengalai': 'kalai',
'mengalaikan': 'kalai',
'kalangan': 'kalang',
'kalangannya': 'kalang',
'kalangani': 'kalang',
'kalanganmu': 'kalang',
'terkalang': 'kalang',
'berkalang': 'kalang',
'berkalangan': 'kalang',
'kalang kabut': 'kalang',
'kekalapan': 'kalap',
'kalengan': 'kaleng',
'pengalengan': 'kaleng',
'mengalengkan': 'kaleng',
'kaleng-kalengan': 'kaleng',
'sekali': 'kali',
'sekalinya': 'kali',
'sekalilah': 'kali',
'sekalikan': 'kali',
'sekalii': 'kali',
'sekalian': 'kali',
'pengali': 'kali',
'pengalinya': 'kali',
'pengalilah': 'kali',
'pengalian': 'kali',
'sekalianlah': 'kali',
'sesekali': 'sekali',
'sesekalinya': 'sekali',
'perkalian': 'kali',
'perkaliannya': 'kali',
'kali-kalian': 'kali',
'kali-kaliannya': 'kali',
'sekali-kali': 'kali',
'sekali-kalinya': 'kali',
'sekali-sekali': 'kali',
'sekali-sekalinya': 'kali',
'berka-li-kali': 'kali',
'memperkalikan': 'kali',
'mengalicau': 'kalicau',
'mengalicaukan': 'kalicau',
'berkalih': 'kalih',
'mengalimantang': 'kalimantang',
'mengalkulasi': 'kalkulasi',
'mengalkulasinya': 'kalkulasi',
'mengalkulasikan': 'kalkulasi',
'mengalkulasikannya': 'kalkulasi',
'sekalung': 'kalung',
'berkalung': 'kalung',
'berkalungkan': 'kalung',
'mengalungkan': 'kalung',
'mengalungkannya': 'kalung',
'kekalutan': 'kalut',
'kekalutannya': 'kalut',
'mengalutkan': 'kalut',
'mengalutmalutkan': 'kalut-malut',
'berkamar': 'kamar',
'mengamban': 'kamban',
'mengambi': 'kambi',
'mengambilah': 'kambi',
'berkambi': 'kambi',
'mengambinghitamkan': 'kambing hitam',
'mengambinghitamkankan': 'kambing hitam',
'kambuhan': 'kambuh',
'kambuhannya': 'kambuh',
'terkambus': 'kambus',
'mengamitkan': 'kamit',
'kamit-kamit': 'kamit',
'berkamit-kamit': 'kamit',
'mengamit-ngamitkan': 'kamit',
'berkampai': 'kampai',
'terkampai': 'kampai',
'berkampaian': 'kampai',
'berkampanye': 'kampanye',
'berkampanyenya': 'kampanye',
'berkampanyelah': 'kampanye',
'mengampanyekan': 'kampanye',
'mengampanyekannya': 'kampanye',
'mengampas': 'kampas',
'berkampuh': 'kampuh',
'terkampul-kampul': 'kampul',
'kampungan': 'kampung',
'berkampung': 'kampung',
'mengampung': 'kampung',
'mengampungi': 'kampung',
'perkampungan': 'kampung',
'perkampungannya': 'kampung',
'berkamu': 'kamu',
'mengamuflase': 'kamuflase',
'mengamuflasekan': 'kamuflase',
'berkamuflase': 'kamuflase',
'pekamus': 'kamus',
'mengamus': 'kamus',
'pengamusan': 'kamus',
'perkamusan': 'kamus',
'mengamuskan': 'kamus',
'kekanak-kanakan': 'kanak-kanak',
'kekanak-kanakannya': 'kanak-kanak',
'kekanak-kanakanan': 'kanak-kanak',
'penganalan': 'kanal',
'menganan': 'kanan',
'menganankan': 'kanan',
'menganani': 'kanan',
'terkanan': 'kanan',
'terkanannya': 'kanan',
'sekancah': 'kancah',
'terkancah': 'kancah',
'terkanceh': 'kanceh',
'pengancing': 'kancing',
'pengancingan': 'kancing',
'terkancing': 'kancing',
'mengancing': 'kancing',
'mengancingkan': 'kancing',
'mengancingkannya': 'kancing',
'mengancingi': 'kancing',
'sekandang': 'kandang',
'sekandangnya': 'kandang',
'perkandangan': 'kandang',
'mengandangkan': 'kandang',
'mengandangkannya': 'kandang',
'kandaran': 'kandar',
'kandarani': 'kandar',
'mengandar': 'kandar',
'pengandar': 'kandar',
'pengandaran': 'kandar',
'terkandas': 'kandas',
'mengandaskan': 'kandas',
'mengandaskannya': 'kandas',
'mengandidatkan': 'kandidat',
'mengandul': 'kandul',
'berkandul': 'kandul',
'dikandung': 'kandung',
'dikandungnya': 'kandung',
'dikandungan': 'kandung',
'kandungan': 'kandung',
'kandungannya': 'kandung',
'kandunganku': 'kandung',
'kandunganmu': 'kandung',
'mengandung': 'kandung',
'mengandungnya': 'kandung',
'mengandungi': 'kandung',
'mengandungan': 'kandung',
'mengandungmu': 'kandung',
'pengandung': 'kandung',
'terkandung': 'kandung',
'terkandungnya': 'kandung',
'terkandungan': 'kandung',
'berkandung': 'kandung',
'berkandungan': 'kandung',
'berkandungankan': 'kandung',
'kandutan': 'kandut',
'mengandut': 'kandut',
'berkang': 'kang',
'mengangeni': 'kangen',
'kangen-kangenan': 'kangen',
'mengangkang': 'kangkang',
'mengangkangkan': 'kangkang',
'mengangkangi': 'kangkang',
'terkangkang': 'kangkang',
'mengangkanginya': 'kangkang',
'penganibalan': 'kanibal',
'berkanjang': 'kanjang',
'berkanjar': 'kanjar',
'terkanjar-kanjar': 'kanjar',
'berkanjar-kanjar': 'kanjar',
'mengansel': 'kansel',
'kekanseliran': 'kanselir',
'mengantang': 'kantang',
'berkantaran': 'kantar',
'penganti': 'kanti',
'pengantinya': 'kanti',
'pengantian': 'kanti',
'berkantong': 'kantong',
'mengantongi': 'kantong',
'mengantonginya': 'kantong',
'pengantongan': 'kantong',
'berkantor': 'kantor',
'berkantornya': 'kantor',
'perkantoran': 'kantor',
'perkantorannya': 'kantor',
'terkantuk': 'kantuk',
'terkantuk-kantuk': 'kantuk',
'menganvaskan': 'kanvas',
'menganvaskannya': 'kanvas',
'mengaoki': 'kaok',
'berkaok-kaok': 'kaok',
'kapa-kapa': 'kapa',
'terkapah-kapah': 'kapah',
'terkapai-kapai': 'kapai',
'berkapak': 'kapak',
'kapalan': 'kapal',
'berkapal': 'kapal',
'perkapalan': 'kapal',
'perkapalannya': 'kapal',
'pengapalan': 'kapal',
'pengapalannya': 'kapal',
'mengapalkan': 'kapal',
'mengapalkannya': 'kapal',
'kapan-kapan': 'kapan',
'kapan-kapannya': 'kapan',
'kapangan': 'kapang',
'berkapang': 'kapang',
'berkapas': 'kapas',
'berkapasitas': 'kapasitas',
'berkapitulasi': 'kapitulasi',
'mengapokkan': 'kapok',
'mengapteni': 'kapten',
'kapu-kapu': 'kapu',
'terkapung-kapung': 'kapung',
'mengapur': 'kapur',
'mengapurkan': 'kapur',
'pekapuran': 'kapur',
'pengapuran': 'kapur',
'perkapuran': 'kapur',
'sekapur sirih': 'kapur sirih',
'berkarakter': 'karakter',
'berkarakternya': 'karakter',
'berkarakterlah': 'karakter',
'mengaram': 'karam',
'mengaramkan': 'karam',
'mengarami': 'karam',
'karangan': 'karang',
'karangannya': 'karang',
'karanganan': 'karang',
'karanganku': 'karang',
'pengarang': 'karang',
'pengarangnya': 'karang',
'berkarang': 'karang',
'pekarangan': 'karang',
'pekarangannya': 'karang',
'pekaranganku': 'karang',
'pekaranganmu': 'karang',
'kepengarangan': 'karang',
'karang-karangan': 'karang',
'karang-karangannya': 'karang',
'karang-mengarang': 'karang',
'mengarang-ngarang': 'karang',
'mengarantinakan': 'karantina',
'berkaraoke': 'karaoke',
'karas hati': 'karatan',
'berkarau': 'karau',
'mengarau': 'karau',
'pengarauan': 'karau',
'karbidan': 'karbida',
'mengarbida': 'karbida',
'mengarbol': 'karbol',
'dikarenakan': 'karena',
'dikarenakannya': 'karena',
'mengaret': 'karet',
'mengareti': 'karet',
'perkaretan': 'karet',
'mengarib': 'karib',
'berkarib': 'karib',
'mengaribi': 'karib',
'kekariban': 'karib',
'perkariban': 'karib',
'mengaribkan': 'karib',
'berkarier': 'karier',
'berkariernya': 'karier',
'berkarierlah': 'karier',
'pengarih': 'karih',
'berkarpet': 'karpet',
'pengartuan': 'kartu',
'perkartuan': 'kartu',
'mengartukan': 'kartu',
'mengartumerahkan': 'kartu merah',
'berkaru': 'karu',
'mengaru': 'karu',
'berkarung': 'karung',
'berkarung-karung': 'karung',
'mengaruniai': 'karunia',
'mengaruniainya': 'karunia',
'mengaruniakan': 'karunia',
'mengarut': 'karut',
'berkarut': 'karut',
'karut-marut': 'karut',
'karut-marutnya': 'karut',
'berkarya': 'karya',
'berkaryanya': 'karya',
'berkaryalah': 'karya',
'kekaryaan': 'karya',
'kekaryaannya': 'karya',
'pengaryaan': 'karya',
'mengaryakan': 'karya',
'mengasadkan': 'kasad',
'berkasak-kusuk': 'kasak-kusuk',
'kasap jantan': 'kasap',
'kekasaran': 'kasar',
'kekasarannya': 'kasar',
'mengasari': 'kasar',
'mengasarinya': 'kasar',
'mengasariku': 'kasar',
'memperkasar': 'kasar',
'mengasarkan': 'kasar',
'perkasetan': 'kaset',
'mengasetkan': 'kaset',
'berkasidah': 'kasidah',
'mengasidahkan': 'kasidah',
'pekasih': 'kasih',
'kekasih': 'kasih',
'kekasihnya': 'kasih',
'kekasihkan': 'kasih',
'kekasihku': 'kasih',
'kekasihmu': 'kasih',
'kekasih-ku': 'kasih',
'berkasih': 'kasih',
'mengasih': 'kasih',
'mengasihnya': 'kasih',
'mengasihkan': 'kasih',
'mengasihkannya': 'kasih',
'mengasihi': 'kasih',
'pengasih': 'kasih',
'pengasihan': 'kasih',
'mengasihinya': 'kasih',
'mengasihiku': 'kasih',
'mengasihimu': 'kasih',
'berkasih-kasihan': 'kasih',
'mengasihani': 'kasihan',
'mengasihaninya': 'kasihan',
'mengasim': 'kasim',
'mengastrasi': 'kastrasi',
'terkatah-katah': 'katah',
'berkatak-katak': 'katak',
'mengatalisasi': 'katalisasi',
'mengatalisis': 'katalisis',
'mengatalisit': 'katalisit',
'pengatalog': 'katalog',
'perkatalogan': 'katalog',
'pengatalogan': 'katalog',
'mengatalogkan': 'katalog',
'berkategori': 'kategori',
'terkategori': 'kategori',
'terkategorikan': 'kategori',
'mengategorikan': 'kategori',
'mengategorikannya': 'kategori',
'sekati': 'kati',
'sekatinya': 'kati',
'katian': 'kati',
'katiannya': 'kati',
'dikati': 'kati',
'dikatikan': 'kati',
'mengati': 'kati',
'mengatikan': 'kati',
'mengatikannya': 'kati',
'mengatrol': 'katrol',
'mengatrolnya': 'katrol',
'terkatung-katung': 'katung',
'terkatung-katungnya': 'katung',
'terkatup': 'katup',
'terkatupnya': 'katup',
'mengatup': 'katup',
'mengatupnya': 'katup',
'mengatupkan': 'katup',
'mengatupkannya': 'katup',
'memperkatupkan': 'katup',
'mengatup-ngatupkan': 'katup',
'kaulan': 'kaul',
'berkaul': 'kaul',
'mengaulkan': 'kaul',
'kauman': 'kaum',
'berkaum': 'kaum',
'perkauman': 'kaum',
'berkaus': 'kaus',
'mengaut': 'kaut',
'mengautkan': 'kaut',
'mengaveling': 'kaveling',
'berkaveling': 'kaveling',
'pengavelingan': 'kaveling',
'mengkaver': 'kaver',
'kawakan': 'kawak',
'kawakannya': 'kawak',
'kawalan': 'kawal',
'kawalannya': 'kawal',
'kawalanan': 'kawal',
'berkawal': 'kawal',
'pengawal': 'kawal',
'pengawalnya': 'kawal',
'pengawali': 'kawal',
'pengawalan': 'kawal',
'mengawal': 'kawal',
'mengawalnya': 'kawal',
'mengawallah': 'kawal',
'mengawalkan': 'kawal',
'mengawalan': 'kawal',
'mengawalku': 'kawal',
'mengawalmu': 'kawal',
'pengawalannya': 'kawal',
'pengawalanlah': 'kawal',
'pengawalanan': 'kawal',
'mengawih': 'kawih',
'berkawin': 'kawin',
'pengawin': 'kawin',
'mengawin': 'kawin',
'mengawinkan': 'kawin',
'mengawinkannya': 'kawin',
'mengawini': 'kawin',
'mengawininya': 'kawin',
'mengawinimu': 'kawin',
'perkawinan': 'kawin',
'perkawinannya': 'kawin',
'perkawinanan': 'kawin',
'perkawinanku': 'kawin',
'mengawinkankan': 'kawin',
'kawin-mawin': 'kawin',
'terkaya': 'kaya',
'terkayanya': 'kaya',
'terkayakan': 'kaya',
'kekayaan': 'kaya',
'kekayaannya': 'kaya',
'kekayaanan': 'kaya',
'kekayaanmu': 'kaya',
'pengayaan': 'kaya',
'pengayaannya': 'kaya',
'memperkaya': 'kaya',
'memperkayanya': 'kaya',
'terkayai': 'kayai',
'mengayaikan': 'kayai',
'pengayau': 'kayau',
'pengayauan': 'kayau',
'mengayau': 'kayau',
'berkayau': 'kayau',
'berkayu': 'kayu',
'berkayunya': 'kayu',
'kekayuan': 'kayu',
'perkayuan': 'kayu',
'kayu-kayu': 'kayu',
'kayu-kayunya': 'kayu',
'kayu-kayuan': 'kayu',
'mengebal': 'kebal',
'mengebalkan': 'kebal',
'kekebalan': 'kebal',
'kekebalannya': 'kebal',
'pengebalan': 'kebal',
'mengebas': 'kebas',
'mengebaskan': 'kebas',
'sekebat': 'kebat',
'pengebat': 'kebat',
'mengebat': 'kebat',
'terkebat': 'kebat',
'mengebatkan': 'kebat',
'kebat-kebit': 'kebat',
'terkebiri': 'kebiri',
'terkebirinya': 'kebiri',
'mengebiri': 'kebiri',
'mengebirinya': 'kebiri',
'pengebirian': 'kebiri',
'pengebiriannya': 'kebiri',
'mengebur': 'kebur',
'pengebut': 'kebut',
'pengebutan': 'kebut',
'mengebut': 'kebut',
'mengebutkan': 'kebut',
'mengebuti': 'kebut',
'kebut-kebutan': 'kebut',
'kebut-kebutannya': 'kebut',
'kebut-kebutanan': 'kebut',
'berkebyaran': 'kebyar',
'berkecak pinggang': 'kecak pinggang',
'kecaman': 'kecam',
'kecamannya': 'kecam',
'kecamanan': 'kecam',
'mengecam': 'kecam',
'mengecamnya': 'kecam',
'mengecamkan': 'kecam',
'mengecaman': 'kecam',
'mengecamku': 'kecam',
'pengecam': 'kecam',
'pengecamnya': 'kecam',
'pengecaman': 'kecam',
'berkecandan': 'kecandan',
'kecapan': 'kecap',
'pengecap': 'kecap',
'pengecapnya': 'kecap',
'terkecap-kecap': 'kecap',
'dikecek': 'kecek',
'berkecek-kecek': 'kecek',
'sekeceng': 'keceng',
'mengeceng': 'keceng',
'mengecengkan': 'keceng',
'terkecewa': 'kecewa',
'kekecewaan': 'kecewa',
'kekecewaannya': 'kecewa',
'kekecewaanlah': 'kecewa',
'mengecewakan': 'kecewa',
'mengecewakannya': 'kecewa',
'mengecewakanku': 'kecewa',
'mengecewakanmu': 'kecewa',
'berkeciak': 'keciak',
'berkecibakan': 'kecibak',
'berkecil hati': 'kecil hati',
'sekecil': 'kecil',
'sekecilnya': 'kecil',
'kecilan': 'kecil',
'mengecil': 'kecil',
'mengecilnya': 'kecil',
'mengecilkan': 'kecil',
'mengecilkannya': 'kecil',
'kekecilan': 'kecil',
'kekecilannya': 'kecil',
'kekecilanlah': 'kecil',
'pengecilan': 'kecil',
'memperkecil': 'kecil',
'memperkecilnya': 'kecil',
'memperkecilkan': 'kecil',
'kecil-kecilan': 'kecil',
'kecil-kecilannya': 'kecil',
'kecil-mengecil': 'kecil',
'berkecil-kecil': 'kecil',
'berkecil-kecilan': 'kecil',
'kecomak-kecimik': 'kecimik',
'mengecimus': 'kecimus',
'berkecipak': 'kecipak',
'pengecoh': 'kecoh',
'pengecohan': 'kecoh',
'terkecoh': 'kecoh',
'terkecohnya': 'kecoh',
'mengecoh': 'kecoh',
'mengecohnya': 'kecoh',
'mengecohkan': 'kecoh',
'mengecohku': 'kecoh',
'mengecu': 'kecu',
'berkecuali': 'kecuali',
'mengecuali': 'kecuali',
'mengecualikan': 'kecuali',
'mengecualikannya': 'kecuali',
'mengecualian': 'kecuali',
'terkecuali': 'kecuali',
'terkecualikan': 'kecuali',
'kekecualian': 'kecuali',
'perkecualian': 'kecuali',
'perkecualiannya': 'kecuali',
'pengecualian': 'kecuali',
'pengecualiannya': 'kecuali',
'memperkecualikan': 'kecuali',
'berkecumik': 'kecumik',
'kecupan': 'kecup',
'kecupannya': 'kecup',
'mengecup': 'kecup',
'mengecupnya': 'kecup',
'mengecupkan': 'kecup',
'pengecut': 'kecut',
'pengecutnya': 'kecut',
'mengecut': 'kecut',
'mengecutkan': 'kecut',
'kekecutan': 'kecut',
'kepengecutan': 'kecut',
'berkedal': 'kedal',
'pengedang': 'kedang',
'mengedang': 'kedang',
'mengedangkan': 'kedang',
'mengedau': 'kedau',
'kedek-kedek': 'kedek',
'terkedek-kedek': 'kedek',
'kedekak-kedekik': 'kedekik',
'kedewaga': 'kedewas',
'mengedik': 'kedik',
'mengedikkan': 'kedik',
'terkedik': 'kedik',
'berkedip': 'kedip',
'berkediplah': 'kedip',
'terkedip': 'kedip',
'mengedipkan': 'kedip',
'mengedipkannya': 'kedip',
'terkedip-kedip': 'kedip',
'berkedip-kedip': 'kedip',
'berkedok': 'kedok',
'berkedokkan': 'kedok',
'memperkedok': 'kedok',
'kekedotan': 'kedot',
'mengeduk': 'keduk',
'terkehel': 'kehel',
'mengejai': 'kejai',
'berkejai': 'kejai',
'terkejam': 'kejam',
'mengejam': 'kejam',
'kekejaman': 'kejam',
'kekejamannya': 'kejam',
'kekejamanan': 'kejam',
'mengejami': 'kejam',
'mengejamkan': 'kejam',
'berkejang': 'kejang',
'mengejang': 'kejang',
'mengejangnya': 'kejang',
'mengejangkan': 'kejang',
'kekejangan': 'kejang',
'berkejang-kejang': 'kejang',
'kejang-kejang': 'mengejang',
'kejang-kejangnya': 'mengejang',
'kejapan': 'kejap',
'kejapanan': 'kejap',
'sekejap': 'kejap',
'berkejap': 'kejap',
'mengejap': 'kejap',
'mengejapkan': 'kejap',
'berkejap-kejap': 'kejap',
'dikejar': 'kejar',
'dikejarnya': 'kejar',
'dikejarkan': 'kejar',
'kejaran': 'kejar',
'kejarannya': 'kejar',
'mengejar': 'kejar',
'mengejarnya': 'kejar',
'mengejarkan': 'kejar',
'mengejari': 'kejar',
'mengejaran': 'kejar',
'mengejarku': 'kejar',
'mengejarmu': 'kejar',
'terkejar': 'kejar',
'berkejaran': 'kejar',
'bersikejar': 'kejar',
'pengejaran': 'kejar',
'pengejarannya': 'kejar',
'kejar-mengejar': 'kejar',
'terkejar-kejar': 'kejar',
'mengejar-ngejar': 'kejar',
'mengejar-ngejarnya': 'kejar',
'berkejar-kejaran': 'kejar',
'berkeji': 'keji',
'kekejian': 'keji',
'kekejiannya': 'keji',
'mengejikan': 'keji',
'mengejuju': 'kejuju',
'kejutan': 'kejut',
'kejutannya': 'kejut',
'terkejut': 'kejut',
'terkejutnya': 'kejut',
'terkejutlah': 'kejut',
'terkejutkan': 'kejut',
'terkejutan': 'kejut',
'berkejut': 'kejut',
'mengejut': 'kejut',
'mengejutnya': 'kejut',
'mengejutkan': 'kejut',
'mengejutkannya': 'kejut',
'mengejutan': 'kejut',
'pengejut': 'kejut',
'pengejutkan': 'kejut',
'mengejuti': 'kejut',
'kekejutan': 'kejut',
'kekejutannya': 'kejut',
'berkejutan': 'kejut',
'mengejutkanlah': 'kejut',
'mengejutkankan': 'kejut',
'mengejutkanku': 'kejut',
'kejut-kejut': 'kejut',
'kejut-kejutan': 'kejut',
'keterkejutan': 'kejut',
'keterkejutannya': 'kejut',
'berkejut telinga': 'kejut',
'mengejut-ngejuti': 'kejut',
'mengekah': 'kekah',
'kekangan': 'kekang',
'terkekang': 'kekang',
'terkekangnya': 'kekang',
'mengekang': 'kekang',
'mengekangnya': 'kekang',
'mengekangi': 'kekang',
'mengekangan': 'kekang',
'pengekangan': 'kekang',
'mengekar': 'kekar',
'mengekarkan': 'kekar',
'mengekas': 'kekas',
'terkekau-kekau': 'kekau',
'terkekeh-kekeh': 'kekeh',
'mengekek': 'kekek',
'terkekek-kekek': 'kekek',
'mengelam': 'kelam',
'mengelamkan': 'kelam',
'mengelami': 'kelam',
'berkelam': 'kelam',
'kekelaman': 'kelam',
'pengelaman': 'kelam',
'pengelamannya': 'kelam',
'mengenyal': 'kenyal',
'mengenyalkan': 'kenyal',
'kekenyalan': 'kenyal',
'kekenyalannya': 'kenyal',
'kekenyangan': 'kenyang',
'kekenyangannya': 'kenyang',
'sekenyangnya': 'kenyang',
'mengenyangkan': 'kenyang',
'sekenyang-kenyangnya': 'kenyang',
'mengeker': 'keker',
'kikiran': 'kikir',
'kikirannya': 'kikir',
'mengikir': 'kikir',
'berkikir': 'kikir',
'kekikiran': 'kikir',
'mengekol': 'kol',
'berkukuh': 'kukuh',
'berkukuhnya': 'kukuh',
'mengukuhi': 'kukuh',
'kekukuhan': 'kukuh',
'kekukuhannya': 'kukuh',
'pengukuhan': 'kukuh',
'pengukuhannya': 'kukuh',
'memperkukuh': 'kukuh',
'memperkukuhkan': 'kukuh',
'mengukuhkan': 'kukuh',
'mengukuhkannya': 'kukuh',
'menguning': 'kuning',
'menguningnya': 'kuning',
'menguningkan': 'kuning',
'kekuningan': 'kuning',
'kekuning-kuningan': 'kuning',
'kekunoan': 'kuno',
'kekunoannya': 'kuno',
'kurusan': 'kurus',
'mengurus': 'urus',
'mengurusnya': 'urus',
'menguruskan': 'urus',
'menguruskannya': 'urus',
'mengurusi': 'urus',
'mengurusan': 'urus',
'mengurusmu': 'urus',
'kekurusan': 'kurus',
'pengurusan': 'urus',
'pengurusannya': 'urus',
'mengusut': 'usut',
'mengusutnya': 'usut',
'mengusutkan': 'usut',
'mengusuti': 'usut',
'mengusutan': 'usut',
'kekusutan': 'kusut',
'kekusutannya': 'kusut',
'berkusut-kusut': 'kusut',
'kelabakan': 'kelabak',
'kelabangan': 'kelabang',
'berkelabang': 'kelabang',
'mengelabang': 'kelabang',
'mengelabui': 'kelabu',
'mengelabuinya': 'kelabu',
'pengelabuan': 'kelabu',
'pengelabuannya': 'kelabu',
'mengeladau': 'keladau',
'mengelah': 'kelah',
'mengelahkan': 'kelah',
'mengelai': 'kelai',
'mengelai-ngelai': 'kelai',
'pelalai': 'lalai',
'pelalaian': 'lalai',
'terlalai': 'lalai',
'terlalaikan': 'lalai',
'kelalaian': 'lalai',
'kelalaiannya': 'lalai',
'melalaikan': 'lalai',
'melalaikannya': 'lalai',
'memperlalaikan': 'lalai',
'berlalai-lalai': 'lalai',
'berkelambu': 'kelambu',
'sekelamin': 'kelamin',
'berkelamin': 'kelamin',
'mengelamini': 'kelamin',
'berlancang': 'lancang',
'kelancangan': 'lancang',
'kelancangannya': 'lancang',
'lancang-lancang': 'lancang',
'lancaran': 'lancar',
'pelancar': 'lancar',
'pelancarkan': 'lancar',
'pelancaran': 'lancar',
'melancar': 'lancar',
'melancarkan': 'lancar',
'melancarkannya': 'lancar',
'melancaran': 'lancar',
'kelancaran': 'lancar',
'kelancarannya': 'lancar',
'kelancaranan': 'lancar',
'kelancaranmu': 'lancar',
'memperlancar': 'lancar',
'memperlancarnya': 'lancar',
'memperlancarkan': 'lancar',
'memperlancaran': 'lancar',
'mengelanjar': 'kelanjar',
'berkelanjaran': 'kelanjar',
'mengelantang': 'kelantang',
'sekelap': 'kelap',
'kelap-kelip': 'terkelap',
'mengelapkan': 'lap',
'sekelap': 'terkelap',
'berlapar': 'lapar',
'kelaparan': 'lapar',
'kelaparannya': 'lapar',
'kelaparanlah': 'lapar',
'melaparkan': 'lapar',
'berkelar': 'kelar',
'mengelar': 'kelar',
'mengelarkan': 'kelar',
'berkelar-kelar': 'kelar',
'mengelarai': 'kelarai',
'melarut': 'larut',
'melarutnya': 'larut',
'melarutkan': 'larut',
'melarutkannya': 'larut',
'pelarut': 'larut',
'pelarutnya': 'larut',
'pelarutan': 'larut',
'larutan': 'larut',
'larutannya': 'larut',
'terlarut': 'larut',
'terlarutnya': 'larut',
'terlarutkan': 'larut',
'kelarutan': 'larut',
'kelarutannya': 'larut',
'pelarutannya': 'larut',
'berlarut-larut': 'larut',
'berlarut-larutnya': 'larut',
'keberlarut-larutan': 'larut',
'mengelas': 'las',
'mengelasnya': 'las',
'berkelas': 'kelas',
'berkelasnya': 'kelas',
'mengelaskan': 'kelas',
'kelasah-kelusuh': 'kelasah',
'pengelat': 'kelat',
'pelaut': 'laut',
'pelautnya': 'laut',
'lautan': 'laut',
'lautannya': 'laut',
'melaut': 'laut',
'melautnya': 'laut',
'melauti': 'laut',
'pelautan': 'laut',
'kelautan': 'laut',
'kelautannya': 'laut',
'kelautanlah': 'laut',
'kelautanan': 'laut',
'melautkan': 'laut',
'melayak': 'layak',
'melayakkan': 'layak',
'melayakan': 'layak',
'layaknya': 'layak',
'terlayak': 'layak',
'kelayakan': 'layak',
'kelayakannya': 'layak',
'kelayakanan': 'layak',
'kelayakanku': 'layak',
'kelayakanmu': 'layak',
'selayaknya': 'layak',
'selayaknyalah': 'layak',
'melayu': 'layu',
'melayunya': 'layu',
'pelayuan': 'layu',
'pelayuanan': 'layu',
'kelayuan': 'layu',
'layu-layuan': 'layu',
'kelebatan': 'kelebat',
'sekelebat': 'kelebat',
'sekelebatan': 'kelebat',
'berkelebat': 'kelebat',
'berkelebatnya': 'kelebat',
'berkelebatan': 'kelebat',
'mengelebatkan': 'kelebat',
'mengelebekkan': 'kelebek',
'mengelebukan': 'kelebu',
'berkeledar': 'keledar',
'berkelejat': 'kelejat',
'kelek-kelek': 'kelek',
'kelek-kelekan': 'kelek',
'berkelelot': 'kelelot',
'mengelelotkan': 'kelelot',
'kelembaman': 'lembam',
'berkelemban': 'kelemban',
'pelembap': 'lembap',
'pelembapnya': 'lembap',
'pelembapan': 'lembap',
'kelembapan': 'lembap',
'kelembapannya': 'lembap',
'melembapkan': 'lembap',
'melembapkannya': 'lembap',
'berkelembapan': 'lembap',
'pelembut': 'lembut',
'pelembutnya': 'lembut',
'pelembutan': 'lembut',
'terlembut': 'lembut',
'kelembutan': 'lembut',
'kelembutannya': 'lembut',
'melembutkan': 'lembut',
'melembutkannya': 'lembut',
'terkelempai': 'kelempai',
'kelengangan': 'lengang',
'melengangkan': 'lengang',
'mengelenggarakan': 'kelenggara',
'kelenyapan': 'lenyap',
'melenyapkan': 'lenyap',
'melenyapkannya': 'lenyap',
'melenyapkanku': 'lenyap',
'terkelepai': 'kelepai',
'mengelepai': 'kelepai',
'berkelepai': 'kelepai',
'berkelepai-kelepai': 'kelepai',
'mengelepat': 'kelepat',
'terkelepek': 'kelepek',
'terkelepet': 'kelepet',
'mengelepik-ngelepik': 'kelepik',
'mengelepur': 'kelepur',
'mengelesot': 'kelesot',
'kelesuan': 'lesu',
'kelesuannya': 'lesu',
'berkeletah': 'keletah',
'berletih': 'letih',
'keletihan': 'letih',
'keletihannya': 'letih',
'meletihkan': 'letih',
'berletih-letih': 'letih',
'melewah': 'lewah',
'kelewahan': 'lewah',
'kelewat': 'lewat',
'kelewatan': 'lewat',
'selewat': 'lewat',
'selewatnya': 'lewat',
'selewatan': 'lewat',
'terlewat': 'lewat',
'terlewatnya': 'lewat',
'terlewatkan': 'lewat',
'terlewatkannya': 'lewat',
'terlewati': 'lewat',
'melewati': 'lewat',
'melewatinya': 'lewat',
'melewatiku': 'lewat',
'melewatimu': 'lewat',
'terlewatinya': 'lewat',
'terlewatikan': 'lewat',
'berlewatan': 'lewat',
'melewatkan': 'lewat',
'melewatkannya': 'lewat',
'melewatkanmu': 'lewat',
'berkeliaran': 'keliar',
'berkeliarannya': 'keliar',
'berkelibang': 'kelibang',
'berkelibangan': 'kelibang',
'mengelibat': 'kelibat',
'kelicikan': 'licik',
'kelicikannya': 'licik',
'mengelih': 'kelih',
'pelihat': 'lihat',
'pelihatan': 'lihat',
'melihat': 'lihat',
'melihatnya': 'lihat',
'melihatlah': 'lihat',
'melihatkan': 'lihat',
'melihati': 'lihat',
'melihatan': 'lihat',
'melihatku': 'lihat',
'melihatmu': 'lihat',
'terlihat': 'lihat',
'terlihatnya': 'lihat',
'terlihatlah': 'lihat',
'terlihatan': 'lihat',
'kelihatan': 'lihat',
'kelihatannya': 'lihat',
'kelihatanlah': 'lihat',
'penglihat': 'lihat',
'penglihatnya': 'lihat',
'penglihatan': 'lihat',
'penglihatannya': 'lihat',
'penglihatani': 'lihat',
'penglihatanku': 'lihat',
'penglihatanmu': 'lihat',
'melihat-lihat': 'lihat',
'melihat-lihatnya': 'lihat',
'memperlihatkan': 'lihat',
'memperlihatkannya': 'lihat',
'memperlihatkanlah': 'lihat',
'berkelijak': 'kelijak',
'terkelik': 'kelik',
'mengelik': 'kelik',
'mengelikan': 'kelik',
'mengelikkan': 'lik',
'mengelikik': 'kelikik',
'kelilipan': 'kelilip',
'berkelim': 'kelim',
'mengelim': 'kelim',
'pengelim': 'kelim',
'kelincahan': 'lincah',
'kelincahannya': 'lincah',
'melincah-lincah': 'lincah',
'terlincah-lincah': 'lincah',
'berkelindan': 'kelindan',
'berkelindannya': 'kelindan',
'mengeling': 'keling',
'mengelingi': 'keling',
'terkelinjat-kelinjat': 'kelinjat',
'kelintaran': 'kelintar',
'berkelintaran': 'kelintar',
'kelintingan': 'kelinting',
'berkelip': 'kelip',
'kelip-kelip': 'kelip',
'berkelip-kelip': 'kelip',
'terkelip-kelip': 'kelip',
'mengelip-ngelip': 'kelip',
'kekeliruan': 'keliru',
'kekeliruannya': 'keliru',
'pengeliruan': 'keliru',
'mengelirukan': 'keliru',
'mengelis': 'kelis',
'berkelit': 'kelit',
'berkelitnya': 'kelit',
'berkelitlah': 'kelit',
'mengelit': 'kelit',
'mengelitkan': 'kelit',
'mengeliti': 'kelit',
'berkelit-kelit': 'kelit',
'kelobaan': 'loba',
'berkelocak': 'kelocak',
'mengelocak': 'kelocak',
'mengelodan': 'kelodan',
'terkelola': 'kelola',
'terkelolanya': 'kelola',
'pengelola': 'kelola',
'pengelolanya': 'kelola',
'pengelolaan': 'kelola',
'mengelola': 'kelola',
'mengelolanya': 'kelola',
'mengelolakan': 'kelola',
'mengelolaan': 'kelola',
'pengelolaannya': 'kelola',
'terkelolong': 'kelolong',
'kelompokan': 'kelompok',
'mengelompok': 'kelompok',
'mengelompokkan': 'kelompok',
'mengelompokkannya': 'kelompok',
'mengelompokan': 'kelompok',
'berkelompok': 'kelompok',
'berkelompoknya': 'kelompok',
'pengelompokan': 'kelompok',
'pengelompokannya': 'kelompok',
'berkelompok-kelompok': 'kelompok',
'sekelonet': 'kelonet',
'berkelong': 'kelong',
'melonggari': 'longgar',
'kelonggaran': 'longgar',
'kelonggarannya': 'longgar',
'melonggarkan': 'longgar',
'melonggarkannya': 'longgar',
'memperlonggar': 'longgar',
'memperlonggari': 'longgar',
'mengelosok': 'kelosok',
'mengelotok': 'kelotok',
'berkeloyak': 'keloyak',
'terkeloyak': 'keloyak',
'mengeloyor': 'keloyor',
'terkelu': 'kelu',
'mengeluani': 'keluan',
'keluaran': 'keluar',
'keluarannya': 'keluar',
'mengeluari': 'keluar',
'pengeluaran': 'keluar',
'pengeluarannya': 'keluar',
'pengeluaranku': 'keluar',
'pengeluaranmu': 'keluar',
'mengeluarkan': 'keluar',
'mengeluarkannya': 'keluar',
'mengeluarkankan': 'keluar',
'mengeluarkanku': 'keluar',
'mengeluarkanmu': 'keluar',
'keluarbiasaan': 'luar biasa',
'keluarbiasaannya': 'luar biasa',
'meluas': 'luas',
'meluasnya': 'luas',
'meluaslah': 'luas',
'meluaskan': 'luas',
'meluaskannya': 'luas',
'meluasi': 'luas',
'luasan': 'luas',
'luasannya': 'luas',
'keluasan': 'luas',
'peluasan': 'luas',
'peluasannya': 'luas',
'peluasanan': 'luas',
'perluasan': 'luas',
'perluasannya': 'luas',
'memperluas': 'luas',
'memperluasnya': 'luas',
'memperluaskan': 'luas',
'memperluaskannya': 'luas',
'terkelubak': 'kelubak',
'kelucahan': 'lucah',
'keluhan': 'keluh',
'keluhannya': 'keluh',
'keluhanlah': 'keluh',
'keluhanan': 'keluh',
'keluhanku': 'keluh',
'keluhanmu': 'keluh',
'terkeluh': 'keluh',
'berkeluh': 'keluh',
'mengeluh': 'keluh',
'mengeluhnya': 'keluh',
'mengeluhlah': 'keluh',
'mengeluhkan': 'keluh',
'mengeluhkannya': 'keluh',
'mengeluhan': 'keluh',
'pengeluh': 'keluh',
'pengeluhan': 'keluh',
'terkeluk': 'keluk',
'berkeluk': 'keluk',
'berkelukur': 'kelukur',
'berkelukuran': 'kelukur',
'sekelumit': 'kelumit',
'kelumpuhan': 'lumpuh',
'kelumpuhannya': 'lumpuh',
'melumpuhkan': 'lumpuh',
'melumpuhkannya': 'lumpuh',
'berkelumun': 'kelumun',
'mengelumuni': 'kelumun',
'berkelun-kelun': 'kelun',
'mengelupas': 'kelupas',
'mengelupasnya': 'kelupas',
'mengelupaskan': 'kelupas',
'mengelupasi': 'kelupas',
'terkelupas': 'kelupas',
'terkelupasnya': 'kelupas',
'mengelupur': 'kelupur',
'melurus': 'lurus',
'meluruskan': 'lurus',
'meluruskannya': 'lurus',
'melurusan': 'lurus',
'kelurusan': 'lurus',
'selurusan': 'lurus',
'berselurus': 'lurus',
'meluruskanlah': 'lurus',
'selurusnya': 'lurus',
'kelut-melut': 'kelut',
'berkeluyuran': 'keluyur',
'kemagnetan': 'magnet',
'berkemah': 'kemah',
'berkemahnya': 'kemah',
'berkemahlah': 'kemah',
'perkemahan': 'kemah',
'perkemahannya': 'kemah',
'perkemahanan': 'kemah',
'memahiri': 'mahir',
'kemahiran': 'mahir',
'kemahirannya': 'mahir',
'memahirkan': 'mahir',
'mempermahir': 'mahir',
'memaju': 'maju',
'memajukan': 'maju',
'memajukannya': 'maju',
'kemajuan': 'maju',
'kemajuannya': 'maju',
'kemajuanlah': 'maju',
'kemajuanmu': 'maju',
'pemajuan': 'maju',
'kemakmuran': 'makmur',
'kemakmurannya': 'makmur',
'memakmurkan': 'makmur',
'memakmurkannya': 'makmur',
'persemakmuran': 'makmur',
'persemakmurannya': 'makmur',
'berkemal': 'kemal',
'pemalas': 'malas',
'pemalasnya': 'malas',
'pemalasan': 'malas',
'kemalasan': 'malas',
'kemalasannya': 'malas',
'memalaskan': 'malas',
'malas-malasan': 'malas',
'bermalas-malas': 'malas',
'bermalas-malasan': 'malas',
'mengemam': 'kemam',
'kemangkatan': 'mangkat',
'kemangkatannya': 'mangkat',
'kemanjuran': 'manjur',
'kemanjurannya': 'manjur',
'kemanusiaan': 'manusia',
'kemanusiaannya': 'manusia',
'kemanusiaanlah': 'manusia',
'kemanusiaanmu': 'manusia',
'pemanusiaan': 'manusia',
'memanusiakan': 'manusia',
'dikemarikan': 'kemari',
'masukan': 'masuk',
'masukannya': 'masuk',
'masukanlah': 'masuk',
'memasuki': 'masuk',
'memasukinya': 'masuk',
'memasukii': 'masuk',
'termasuk': 'masuk',
'termasuknya': 'masuk',
'termasuklah': 'masuk',
'termasuki': 'masuk',
'termasukan': 'masuk',
'pemasukan': 'masuk',
'pemasukannya': 'masuk',
'pemasukanan': 'masuk',
'pemasukanku': 'masuk',
'pemasukanmu': 'masuk',
'kemasukan': 'masuk',
'kemasukannya': 'masuk',
'memasukkan': 'masuk',
'memasukkannya': 'masuk',
'memasukkanku': 'masuk',
'termasyhur': 'masyhur',
'kemasyhuran': 'masyhur',
'kemasyhurannya': 'masyhur',
'pemasyhuran': 'masyhur',
'memasyhurkan': 'masyhur',
'kematangan': 'matang',
'kematangannya': 'matang',
'kematanganlah': 'matang',
'pematangan': 'matang',
'pematangannya': 'matang',
'mematangkan': 'matang',
'mematangkannya': 'matang',
'kembalian': 'kembali',
'kembaliannya': 'kembali',
'pengembalian': 'kembali',
'pengembaliannya': 'kembali',
'mengembalikan': 'kembali',
'mengembalikannya': 'kembali',
'mengembalikankan': 'kembali',
'mengembalikanku': 'kembali',
'mengembalikanmu': 'kembali',
'berkemban': 'kemban',
'berkembannya': 'kemban',
'berkembang biak': 'kembang biak',
'pengembangbiakan': 'kembang biak',
'pengembangbiakannya': 'kembang biak',
'perkembangbiakan': 'kembang biak',
'perkembangbiakannya': 'kembang biak',
'mengembangbiakkan': 'kembang biak',
'mengembangbiakkannya': 'kembang biak',
'mengembeng': 'kembeng',
'mengembengkan': 'kembeng',
'mengembungkan': 'kembung',
'mengembur': 'kembur',
'mengemburkan': 'kembur',
'berkembur': 'kembur',
'berkembur-kembur': 'kembur',
'bermegah': 'megah',
'kemegahan': 'megah',
'kemegahannya': 'megah',
'memegahkan': 'megah',
'bermegah-megah': 'megah',
'bermegah-megahan': 'megah',
'berkemeja': 'kemeja',
'kemelaratan': 'melarat',
'kemelaratannya': 'melarat',
'memeleset': 'peleset',
'memelesetkan': 'peleset',
'memelesetkannya': 'peleset',
'memelesetan': 'peleset',
'pelesetan': 'peleset',
'pelesetannya': 'peleset',
'terpeleset': 'peleset',
'terpelesetnya': 'peleset',
'kemelesetan': 'peleset',
'pemelesetan': 'peleset',
'berkemendang': 'kemendang',
'mengemendang': 'kemendang',
'berkementam': 'kementam',
'kementerian': 'menteri',
'kementeriannya': 'menteri',
'kementeriani': 'menteri',
'pemerdeka': 'merdeka',
'pemerdekaan': 'merdeka',
'kemerdekaan': 'merdeka',
'kemerdekaannya': 'merdeka',
'kemerdekaanlah': 'merdeka',
'kemerdekaanku': 'merdeka',
'memerdekakan': 'merdeka',
'memerdekakannya': 'merdeka',
'semerdeka-merdekanya': 'merdeka',
'kemerduan': 'merdu',
'termesra': 'mesra',
'kemesraan': 'mesra',
'kemesraannya': 'mesra',
'bermesraan': 'mesra',
'bermesraanlah': 'mesra',
'memesrakan': 'mesra',
'bermesra-mesraan': 'mesra',
'berkemih': 'kemih',
'berkemihnya': 'kemih',
'berkemihlah': 'kemih',
'kemak-kemik': 'kemik',
'kemiringan': 'miring',
'kemiringannya': 'miring',
'memiringkan': 'miring',
'kemiripan': 'mirip',
'kemiripannya': 'mirip',
'kemiripanku': 'mirip',
'bermiripan': 'mirip',
'pemiskinan': 'miskin',
'kemiskinan': 'miskin',
'kemiskinannya': 'miskin',
'kemiskinanlah': 'miskin',
'kemiskinanan': 'miskin',
'kemiskinanku': 'miskin',
'memiskinkan': 'miskin',
'memiskinkannya': 'miskin',
'kemontokan': 'montok',
'kempaan': 'kempa',
'mengempa': 'kempa',
'terkempa': 'kempa',
'pengempaan': 'kempa',
'kempang-kempis': 'kempang',
'mengempis': 'kempis',
'mengempisnya': 'kempis',
'mengempiskan': 'kempis',
'mengempiskannya': 'kempis',
'pengempisan': 'kempis',
'kempas-kempis': 'kempis',
'mengempit': 'kempit',
'kemplangan': 'kemplang',
'mengemplang': 'kemplang',
'mengemplangan': 'kemplang',
'berkempul-kempul': 'kempul',
'terkempul-kempul': 'kempul',
'mengemu': 'kemu',
'mengemukan': 'kemu',
'mengemui': 'kemu',
'berkemu': 'kemu',
'bermudarat': 'mudarat',
'kemudaratan': 'mudarat',
'kemudaratannya': 'mudarat',
'terkemudian': 'kemudian',
'mengemudiankan': 'kemudian',
'kemujaraban': 'mujarab',
'kemujarabannya': 'mujarab',
'mengemuli': 'kemul',
'pemulia': 'mulia',
'pemuliaan': 'mulia',
'termulia': 'mulia',
'kemuliaan': 'mulia',
'kemuliaannya': 'mulia',
'kemuliaanan': 'mulia',
'kemuliaanku': 'mulia',
'pemuliaannya': 'mulia',
'memuliakan': 'mulia',
'memuliakannya': 'mulia',
'mempermulia': 'mulia',
'kemunafikan': 'munafik',
'kemunafikannya': 'munafik',
'kemunafikanlah': 'munafik',
'kemungkinan': 'mungkin',
'kemungkinannya': 'mungkin',
'kemungkinanlah': 'mungkin',
'kemungkinankan': 'mungkin',
'kemungkinanan': 'mungkin',
'kemungkinanku': 'mungkin',
'memungkinkan': 'mungkin',
'memungkinkannya': 'mungkin',
'memungkinkanlah': 'mungkin',
'memungkinkankan': 'mungkin',
'memungkinkanku': 'mungkin',
'memungkinkanmu': 'mungkin',
'memurkai': 'murka',
'kemurkaan': 'murka',
'kemurkaannya': 'murka',
'kemurkaan-mu': 'murka',
'kemurnian': 'murni',
'kemurniannya': 'murni',
'pemurnian': 'murni',
'pemurniannya': 'murni',
'memurnikan': 'murni',
'memurnikannya': 'murni',
'kemurtadan': 'murtad',
'kemurtadannya': 'murtad',
'pemurtadan': 'murtad',
'memurtadkan': 'murtad',
'kemurungan': 'murung',
'kemurungannya': 'murung',
'kemustajaban': 'mustajab',
'terkemut-kemut': 'kemut',
'mengena': 'kena',
'mengenakan': 'kena',
'mengenakannya': 'kena',
'mengenai': 'kena',
'mengenaan': 'kena',
'terkena': 'kena',
'terkenanya': 'kena',
'terkenakan': 'kena',
'terkenai': 'kena',
'mengenainya': 'kena',
'mengenaikan': 'kena',
'mengenaii': 'kena',
'mengenaiku': 'kena',
'mengenaimu': 'kena',
'pengenaan': 'kena',
'pengenaannya': 'kena',
'berkenaan': 'kena',
'berkenaannya': 'kena',
'perkenaan': 'kena',
'perkenaannya': 'kena',
'kena-mengena': 'kena',
'berkena-kenaan': 'kena',
'kenaifan': 'naif',
'kenaifanku': 'naif',
'kenalan': 'kenal',
'kenalannya': 'kenal',
'kenalanan': 'kenal',
'kenalanmu': 'kenal',
'terkenal': 'kenal',
'terkenalnya': 'kenal',
'terkenallah': 'kenal',
'terkenali': 'kenal',
'terkenalan': 'kenal',
'pengenal': 'kenal',
'pengenalnya': 'kenal',
'pengenalan': 'kenal',
'pengenalku': 'kenal',
'mengenal': 'kenal',
'mengenalnya': 'kenal',
'mengenalkan': 'kenal',
'mengenalkannya': 'kenal',
'mengenali': 'kenal',
'mengenalan': 'kenal',
'mengenalku': 'kenal',
'mengenalmu': 'kenal',
'mengenalinya': 'kenal',
'mengenalikan': 'kenal',
'mengenaliku': 'kenal',
'mengenalimu': 'kenal',
'pengenalannya': 'kenal',
'pengenalanan': 'kenal',
'berkenalan': 'kenal',
'berkenalannya': 'kenal',
'berkenalanlah': 'kenal',
'perkenalan': 'kenal',
'perkenalannya': 'kenal',
'perkenalanan': 'kenal',
'perkenalanku': 'kenal',
'perkenalanmu': 'kenal',
'kenal-mengenal': 'kenal',
'memperkenalkan': 'kenal',
'memperkenalkannya': 'kenal',
'memperkenalkankan': 'kenal',
'memperkenalkanku': 'kenal',
'memperkenalkanmu': 'kenal',
'berkenal-kenalan': 'kenal',
'kenangan': 'kenang',
'kenangannya': 'kenang',
'kenangani': 'kenang',
'kenanganan': 'kenang',
'kenanganku': 'kenang',
'kenanganmu': 'kenang',
'mengenang': 'kenang',
'mengenangnya': 'kenang',
'mengenangkan': 'kenang',
'mengenangkannya': 'kenang',
'mengenangi': 'kenang',
'mengenangan': 'kenang',
'mengenangmu': 'kenang',
'terkenang': 'kenang',
'terkenangnya': 'kenang',
'kenang-kenangan': 'kenang',
'kenang-kenangannya': 'kenang',
'kenang-kenanganan': 'kenang',
'menasional': 'nasional',
'menasionalkan': 'nasional',
'penasionalan': 'nasional',
'kenasionalan': 'nasional',
'berkencan': 'kencan',
'berkencannya': 'kencan',
'berkencanlah': 'kencan',
'mengencani': 'kencan',
'mengencaninya': 'kencan',
'mengencaniku': 'kencan',
'kekencangan': 'kencang',
'kekencangannya': 'kencang',
'pengencangan': 'kencang',
'memperkencang': 'kencang',
'kencang-kencung': 'kencang',
'terkencar-kencar': 'kencar',
'terkencing': 'kencing',
'mengencingi': 'kencing',
'mengencinginya': 'kencing',
'perkencingan': 'kencing',
'pengencingan': 'kencing',
'terkencing-kencing': 'kencing',
'kencing-mengencingi': 'kencing',
'mengencongkan': 'kencong',
'mengencreng': 'kencreng',
'mengendalakan': 'kendala',
'kendalian': 'kendali',
'terkendali': 'kendali',
'terkendalinya': 'kendali',
'terkendalilah': 'kendali',
'terkendalikan': 'kendali',
'pengendali': 'kendali',
'pengendalinya': 'kendali',
'pengendalikan': 'kendali',
'pengendalian': 'kendali',
'pengendaliannya': 'kendali',
'pengendalianlah': 'kendali',
'mengendalikan': 'kendali',
'mengendalikannya': 'kendali',
'mengendalikanku': 'kendali',
'mengendalikanmu': 'kendali',
'mengendanai': 'kendana',
'sekendang': 'kendang',
'kendangan': 'kendang',
'kendang-kendang': 'kendang',
'kendang-kendangmu': 'kendang',
'kendang-kendangan': 'kendang',
'kendaraan': 'kendara',
'kendaraannya': 'kendara',
'kendaraanlah': 'kendara',
'kendaraanku': 'kendara',
'kendaraanmu': 'kendara',
'pengendara': 'kendara',
'pengendaranya': 'kendara',
'pengendaralah': 'kendara',
'pengendarai': 'kendara',
'pengendaraan': 'kendara',
'berkendara': 'kendara',
'berkendaranya': 'kendara',
'berkendaralah': 'kendara',
'berkendarakan': 'kendara',
'berkendarai': 'kendara',
'berkendaraan': 'kendara',
'mengendarai': 'kendara',
'mengendarainya': 'kendara',
'berkendaraannya': 'kendara',
'kendatipun': 'kendati',
'kendungan': 'kendung',
'mengendur': 'kendur',
'mengendurnya': 'kendur',
'mengendurkan': 'kendur',
'mengendurkannya': 'kendur',
'kekenduran': 'kendur',
'kekendurannya': 'kendur',
'pengenduran': 'kendur',
'berkendur-kendur': 'kendur',
'berkenduri': 'kenduri',
'mengendurikan': 'kenduri',
'penekat': 'nekat',
'penekatan': 'nekat',
'kenekatan': 'nekat',
'kenekatannya': 'nekat',
'nekat-nekat': 'nekat',
'nekat-nekatan': 'nekat',
'kekenesan': 'kenes',
'kengerian': 'ngeri',
'kengeriannya': 'ngeri',
'kengerianku': 'ngeri',
'mengerikannya': 'ngeri',
'mengengkeng': 'kengkeng',
'mengensel': 'kensel',
'mengental': 'kental',
'mengentalnya': 'kental',
'mengentalkan': 'kental',
'mengentalkannya': 'kental',
'pengental': 'kental',
'pengentalan': 'kental',
'kekentalan': 'kental',
'kekentalannya': 'kental',
'mengentarakan': 'kentara',
'kentungan': 'kentung',
'kentung-kentung': 'kentung',
'kentutan': 'kentut',
'terkentut': 'kentut',
'berkentut': 'kentut',
'mengentuti': 'kentut',
'terkentut-kentut': 'kentut',
'mengenyam': 'kenyam',
'kenyaringan': 'nyaring',
'kenyaringannya': 'nyaring',
'menyaringkan': 'saring',
'kenyat-kenyit': 'kenyat',
'ternyata': 'nyata',
'ternyatanya': 'nyata',
'ternyataan': 'nyata',
'kenyataan': 'nyata',
'kenyataannya': 'nyata',
'kenyataanlah': 'nyata',
'pernyataan': 'nyata',
'pernyataannya': 'nyata',
'pernyataanku': 'nyata',
'pernyataanmu': 'nyata',
'menyatakan': 'nyata',
'menyatakannya': 'nyata',
'menyatakankan': 'nyata',
'menyatakani': 'nyata',
'menyatakanan': 'nyata',
'ternyatakan': 'nyata',
'kenyitan': 'kenyit',
'mengenyit': 'kenyit',
'mengenyitkan': 'kenyit',
'kenyutan': 'kenyut',
'mengenyut': 'kenyut',
'berkeokan': 'keok',
'berkeok-keok': 'keok',
'pemadat': 'padat',
'pemadati': 'padat',
'pemadatan': 'padat',
'padatan': 'padat',
'padatannya': 'padat',
'memadat': 'padat',
'memadatnya': 'padat',
'memadatkan': 'padat',
'memadatkannya': 'padat',
'memadati': 'padat',
'memadatinya': 'padat',
'memadatii': 'padat',
'pemadatannya': 'padat',
'kepadatan': 'padat',
'kepadatannya': 'padat',
'mengepah': 'kepah',
'kepahlawanan': 'pahlawan',
'kepahlawanannya': 'pahlawan',
'kepahlawananan': 'pahlawan',
'kepahlawananmu': 'pahlawan',
'kepakaran': 'pakar',
'kepakarannya': 'pakar',
'kepalan': 'kepal',
'kepalannya': 'kepal',
'sekepal': 'kepal',
'sekepalan': 'kepal',
'terkepal': 'kepal',
'mengepal': 'kepal',
'mengepalkan': 'kepal',
'berkepal-kepal': 'kepal',
'mengepal-ngepalkan': 'kepal',
'berkepala': 'kepala',
'berkepalanya': 'kepala',
'mengepalai': 'kepala',
'mengepalainya': 'kepala',
'mengepalakan': 'kepala',
'kepala-kepalaan': 'kepala',
'pemalsu': 'palsu',
'pemalsunya': 'palsu',
'pemalsukan': 'palsu',
'pemalsuan': 'palsu',
'memalsu': 'palsu',
'memalsukan': 'palsu',
'memalsukannya': 'palsu',
'memalsuan': 'palsu',
'kepalsuan': 'palsu',
'kepalsuannya': 'palsu',
'pemalsuannya': 'palsu',
'pemanas': 'panas',
'pemanasnya': 'panas',
'pemanasan': 'panas',
'memanas': 'panas',
'memanasnya': 'panas',
'memanaskan': 'panas',
'memanaskannya': 'panas',
'memanasi': 'panas',
'memanasan': 'panas',
'berpanas': 'panas',
'berpanasan': 'panas',
'kepanasan': 'panas',
'kepanasannya': 'panas',
'kepanasankan': 'panas',
'terpanasi': 'panas',
'pemanasannya': 'panas',
'pemanasanan': 'panas',
'panas-panas': 'panas',
'panas-panasnya': 'panas',
'panas-panaskan': 'panas',
'panas-panasi': 'panas',
'panas-panasan': 'panas',
'memanas-manasi': 'panas',
'memanas-manasinya': 'panas',
'berpanas-panas': 'panas',
'berpanas-panasan': 'panas',
'memandai': 'pandai',
'memandainya': 'pandai',
'kepandaian': 'pandai',
'kepandaiannya': 'pandai',
'memandaikan': 'pandai',
'sepandai-pandai': 'pandai',
'sepandai-pandainya': 'pandai',
'memandai-mandai': 'pandai',
'berpandai-pandai': 'pandai',
'kepangan': 'kepang',
'kepanganan': 'kepang',
'berkepang': 'kepang',
'mengepang': 'kepang',
'mengepangnya': 'kepang',
'kepang-kepot': 'kepang',
'kepapaan': 'papa',
'kepayahan': 'payah',
'kepayahannya': 'payah',
'memayahkan': 'payah',
'berpayah-payah': 'payah',
'memayah-mayahkan': 'payah',
'kepedaran': 'pedar',
'kepedasan': 'pedas',
'kepedasannya': 'pedas',
'memedaskan': 'pedas',
'kepejalan': 'pejal',
'memejalkan': 'pejal',
'memeka': 'peka',
'memekakan': 'peka',
'memekai': 'peka',
'kepekaan': 'peka',
'kepekaannya': 'peka',
'kepekaanku': 'peka',
'pelikan': 'pelik',
'kepelikan': 'pelik',
'pimpinan': 'pimpin',
'pimpinannya': 'pimpin',
'pimpinanlah': 'pimpin',
'pimpinanan': 'pimpin',
'pimpinannyalah': 'pimpin',
'pimpinanku': 'pimpin',
'pimpinanmu': 'pimpin',
'pemimpin': 'pimpin',
'pemimpinnya': 'pimpin',
'pemimpinlah': 'pimpin',
'pemimpinan': 'pimpin',
'pemimpinku': 'pimpin',
'pemimpinmu': 'pimpin',
'memimpin': 'pimpin',
'memimpinnya': 'pimpin',
'memimpinlah': 'pimpin',
'memimpinkan': 'pimpin',
'memimpinan': 'pimpin',
'berpimpin': 'pimpin',
'terpimpin': 'pimpin',
'terpimpinnya': 'pimpin',
'kepemimpinan': 'pimpin',
'kepemimpinannya': 'pimpin',
'kepemimpinanlah': 'pimpin',
'kepemimpinanan': 'pimpin',
'kepemimpinanku': 'pimpin',
'kepemimpinanmu': 'pimpin',
'kepenatan': 'penat',
'kepenatannya': 'penat',
'memenatkan': 'penat',
'berpenat-penat': 'penat',
'mementing': 'penting',
'mementingnya': 'penting',
'mementingkan': 'penting',
'mementingkannya': 'penting',
'mementingan': 'penting',
'terpenting': 'penting',
'terpentingnya': 'penting',
'terpentingkan': 'penting',
'terpentingan': 'penting',
'terpentingku': 'penting',
'kepentingan': 'penting',
'kepentingannya': 'penting',
'kepentinganlah': 'penting',
'kepentinganku': 'penting',
'kepentinganmu': 'penting',
'berpentingan': 'penting',
'berkepentingan': 'penting',
'berkepentinganlah': 'penting',
'tepercaya': 'percaya',
'memercayai': 'percaya',
'memercayainya': 'percaya',
'memercayaiku': 'percaya',
'memercayaimu': 'percaya',
'kepercayaan': 'percaya',
'kepercayaannya': 'percaya',
'kepercayaanlah': 'percaya',
'kepercayaanan': 'percaya',
'kepercayaanku': 'percaya',
'kepercayaanmu': 'percaya',
'memercayakan': 'percaya',
'memercayakannya': 'percaya',
'bepergian': 'pergi',
'bepergiannya': 'pergi',
'bepergianlah': 'pergi',
'kepergian': 'pergi',
'kepergiannya': 'pergi',
'kepergianku': 'pergi',
'kepergianmu': 'pergi',
'keperkasaan': 'perkasa',
'keperkasaannya': 'perkasa',
'keperluan': 'perlu',
'keperluannya': 'perlu',
'keperluanku': 'perlu',
'keperluanmu': 'perlu',
'seperlunya': 'perlu',
'memerlukan': 'perlu',
'memerlukannya': 'perlu',
'memerlukankan': 'perlu',
'memerlukanan': 'perlu',
'memerlukanku': 'perlu',
'memerlukanmu': 'perlu',
'keperwiraan': 'perwira',
'keperwiraannya': 'perwira',
'kepetahan': 'petah',
'memetahkan': 'petah',
'mengepil': 'kepil',
'terkepil': 'kepil',
'mengepilkan': 'kepil',
'berpilu': 'pilu',
'kepiluan': 'pilu',
'kepiluannya': 'pilu',
'memilukan': 'pilu',
'memilukannya': 'pilu',
'kepilu-piluan': 'pilu',
'sepincang': 'pincang',
'pemincangan': 'pincang',
'kepincangan': 'pincang',
'kepincangannya': 'pincang',
'sekeping': 'keping',
'kepingan': 'keping',
'kepingannya': 'keping',
'mengeping': 'keping',
'pengepingan': 'keping',
'berkeping-keping': 'keping',
'kepitan': 'kepit',
'berkepit': 'kepit',
'mengepit': 'kepit',
'mengeplak': 'keplak',
'keplokan': 'keplok',
'terkepoh': 'kepoh',
'mengepohkan': 'kepoh',
'memompong': 'pompong',
'kepompong': 'pompong',
'kepompongan': 'pompong',
'memongahi': 'pongah',
'kepongahan': 'pongah',
'kepongahannya': 'pongah',
'memongahkan': 'pongah',
'berpongah-pongah': 'pongah',
'mengepot': 'kepot',
'mengeprek': 'keprek',
'kepribadian': 'pribadi',
'kepribadiannya': 'pribadi',
'kepribadianku': 'pribadi',
'kepribadianmu': 'pribadi',
'mempribadikan': 'pribadi',
'mengepris': 'kepris',
'mengepruk': 'kepruk',
'memucat': 'pucat',
'kepucatan': 'pucat',
'pemucatan': 'pucat',
'kepucat-pucatan': 'pucat',
'pengepuh': 'kepuh',
'mengepuh': 'kepuh',
'kepuh-kepuh': 'kepuh',
'memuji': 'puji',
'memujinya': 'puji',
'memujilah': 'puji',
'memujikan': 'puji',
'memujiku': 'puji',
'memujimu': 'puji',
'memuji-mu': 'puji',
'pujian': 'puji',
'pujiannya': 'puji',
'pujiani': 'puji',
'pujianku': 'puji',
'pujianmu': 'puji',
'pemuji': 'puji',
'terpuji': 'puji',
'terpujinya': 'puji',
'terpujilah': 'puji',
'kepujian': 'puji',
'pemujian': 'puji',
'puji-pujian': 'puji',
'berkepuk': 'kepuk',
'mengepukkan': 'kepuk',
'kepulan': 'kepul',
'kepulannya': 'kepul',
'kepulanan': 'kepul',
'berkepul': 'kepul',
'mengepul': 'pul',
'mengepulnya': 'pul',
'mengepulkan': 'pul',
'pengepulan': 'pul',
'berkepul-kepul': 'kepul',
'pulangan': 'pulang',
'sepulang': 'pulang',
'sepulangnya': 'pulang',
'berpulang': 'pulang',
'berpulangnya': 'pulang',
'berpulangan': 'pulang',
'memulangi': 'pulang',
'terpulang': 'pulang',
'pemulangan': 'pulang',
'pemulangannya': 'pulang',
'kepulangan': 'pulang',
'kepulangannya': 'pulang',
'kepulanganmu': 'pulang',
'memulangkan': 'pulang',
'memulangkannya': 'pulang',
'memulangkanku': 'pulang',
'kepulauan': 'pulau',
'kepulauannya': 'pulau',
'pemulauan': 'pulau',
'memulaukan': 'pulau',
'pemutih': 'putih',
'pemutihnya': 'putih',
'pemutihkan': 'putih',
'pemutihan': 'putih',
'memutih': 'putih',
'memutihnya': 'putih',
'memutihkan': 'putih',
'memutihkannya': 'putih',
'memutihan': 'putih',
'keputihan': 'putih',
'keputihannya': 'putih',
'pemutihannya': 'putih',
'keputih-putihan': 'putih',
'pemutus': 'putus',
'pemutusnya': 'putus',
'pemutuskan': 'putus',
'pemutusan': 'putus',
'putusan': 'putus',
'putusannya': 'putus',
'putusanku': 'putus',
'putusanmu': 'putus',
'memutus': 'putus',
'memutusnya': 'putus',
'memutuskan': 'putus',
'memutuskannya': 'putus',
'memutusan': 'putus',
'terputus': 'putus',
'terputusnya': 'putus',
'terputuslah': 'putus',
'terputuskan': 'putus',
'keputusan': 'putus',
'keputusannya': 'putus',
'keputusanku': 'putus',
'keputusanmu': 'putus',
'pemutusannya': 'putus',
'memutuskankan': 'putus',
'memutuskanku': 'putus',
'memutuskanmu': 'putus',
'berputusan': 'putus',
'putus-putus': 'putus',
'putus-putusnya': 'putus',
'berkeputusan': 'putus',
'terputus-putus': 'putus',
'berkerabat': 'kerabat',
'berkerabatan': 'kerabat',
'kekerabatan': 'kerabat',
'kekerabatannya': 'kerabat',
'mengerabik': 'kerabik',
'mengerabikkan': 'kerabik',
'mengerabit': 'kerabit',
'mengerabu': 'kerabu',
'berkerabu': 'kerabu',
'meragu': 'ragu',
'meragunya': 'ragu',
'meragukan': 'raguk',
'meragukannya': 'ragu',
'meraguan': 'ragu',
'keraguan': 'ragu',
'keraguannya': 'ragu',
'keraguanku': 'ragu',
'keraguanmu': 'ragu',
'meragukanlah': 'ragu',
'meragukanku': 'ragu',
'ragu-ragu': 'ragu',
'ragu-ragunya': 'ragu',
'ragu-ragulah': 'ragu',
'kerahan': 'kerah',
'kerahanan': 'kerah',
'pengerah': 'kerah',
'pengerahnya': 'kerah',
'pengerahkan': 'kerah',
'pengerahan': 'kerah',
'berkerah': 'kerah',
'berkerahnya': 'kerah',
'pengerahannya': 'kerah',
'pengerahanan': 'kerah',
'mengerahkan': 'kerah',
'mengerahkannya': 'kerah',
'mengerahkankan': 'kerah',
'kerah-kerahan': 'kerah',
'mengeraikan': 'kerai',
'beraja': 'raja',
'meraja': 'raja',
'merajanya': 'raja',
'merajakan': 'raja',
'merajai': 'raja',
'merajainya': 'raja',
'kerajaan': 'raja',
'kerajaannya': 'raja',
'kerajaanlah': 'raja',
'kerajaanku': 'raja',
'beraja-raja': 'raja',
'perajin': 'rajin',
'perajinnya': 'rajin',
'perajinan': 'rajin',
'kerajinan': 'rajin',
'kerajinannya': 'rajin',
'kerajinanan': 'rajin',
'kerajinanmu': 'rajin',
'pengrajin': 'rajin',
'pengrajinnya': 'rajin',
'pengrajinan': 'rajin',
'merajinkan': 'rajin',
'mengerakah': 'kerakah',
'mengerakahi': 'kerakah',
'mengerakali': 'kerakal',
'kerakusan': 'rakus',
'kerakusannya': 'rakus',
'keraman': 'keram',
'peramah': 'ramah',
'peramahan': 'ramah',
'meramahi': 'ramah',
'keramahan': 'ramah',
'keramahannya': 'ramah',
'keramahanmu': 'ramah',
'beramah-ramah': 'ramah',
'beramah-ramahan': 'ramah',
'berkeramas': 'keramas',
'mengeramasi': 'keramas',
'kekeramatan': 'keramat',
'mengeramatkan': 'keramat',
'mengeramatkannya': 'keramat',
'pekeramik': 'keramik',
'berkerang': 'kerang',
'perkerangan': 'kerang',
'kerang-keruk': 'kerang',
'kerang-kerung': 'kerang',
'kerang-kerangan': 'kerang',
'terkeranjat': 'keranjat',
'kekerapan': 'kerap',
'kekerapannya': 'kerap',
'mengerapkan': 'kerap',
'kerap-kerap': 'kerap',
'kerapian': 'rapi',
'kerapiannya': 'rapi',
'merapikan': 'rapik',
'merapikannya': 'rapi',
'keratan': 'kerat',
'mengerat': 'kerat',
'mengeratnya': 'kerat',
'terkerat': 'kerat',
'pengerat': 'kerat',
'pengeratan': 'kerat',
'kerawangan': 'kerawang',
'mengerawang': 'kerawang',
'mengerbat': 'kerbat',
'mengerbuk': 'kerbuk',
'mengercingkan': 'kercing',
'mengercitkan': 'kercit',
'kekerdilan': 'kerdil',
'kekerdilannya': 'kerdil',
'mengerdomkan': 'kerdom',
'bekerdom-kerdom': 'kerdom',
'mengerebok': 'kerebok',
'mengerecengkan': 'kereceng',
'berkeredong': 'keredong',
'sekerek': 'kerek',
'mengerek': 'kerek',
'mengereknya': 'kerek',
'berkereket': 'kereket',
'seremeh': 'remeh',
'keremehan': 'remeh',
'meremehkan': 'remeh',
'meremehkannya': 'remeh',
'meremehkankan': 'remeh',
'meremehkanku': 'remeh',
'meremehkanmu': 'remeh',
'remeh-temeh': 'remeh',
'remeh-cemeh': 'remeh',
'meremeh-temehkan': 'remeh',
'mengeremus': 'keremus',
'rendahan': 'rendah',
'rendahannya': 'rendah',
'rendahanan': 'rendah',
'merendah': 'rendah',
'merendahnya': 'rendah',
'merendahkan': 'rendah',
'merendahkannya': 'rendah',
'merendahan': 'rendah',
'kerendahan': 'rendah',
'kerendahannya': 'rendah',
'kerendahanmu': 'rendah',
'merendahkankan': 'rendah',
'merendahkanku': 'rendah',
'merendahkanmu': 'rendah',
'merenggang': 'renggang',
'merenggangnya': 'renggang',
'merenggangkan': 'renggang',
'perenggang': 'renggang',
'perenggangkan': 'renggang',
'perenggangan': 'renggang',
'renggangan': 'renggang',
'merenggangi': 'renggang',
'kerenggangan': 'renggang',
'kerenggangannya': 'renggang',
'memperenggang': 'renggang',
'merenggang gawai': 'renggang',
'mengerenyot': 'kerenyot',
'mengerepas': 'kerepas',
'mengerepes': 'kerepes',
'meresah': 'resah',
'meresahkan': 'resah',
'meresahkannya': 'resah',
'meresahan': 'resah',
'keresahan': 'resah',
'keresahannya': 'resah',
'keresahanan': 'resah',
'keresahanmu': 'resah',
'meresahkani': 'resah',
'meresahkanku': 'resah',
'beresah-resah': 'resah',
'terkereseng': 'kereseng',
'berkereta api': 'kereta api',
'perkeretaapian': 'kereta api',
'perkeretaapiannya': 'kereta api',
'berkereta': 'kereta',
'mengeri': 'keri',
'periang': 'riang',
'periangnya': 'riang',
'periangan': 'riang',
'keriangan': 'riang',
'keriangannya': 'riang',
'meriangkan': 'riang',
'mengeriap': 'keriap',
'berkeriapan': 'keriap',
'berkeriau': 'keriau',
'meribut': 'ribut',
'meributkan': 'ribut',
'meributkannya': 'ribut',
'meributi': 'ribut',
'keributan': 'ribut',
'keributannya': 'ribut',
'mengericau': 'kericau',
'berkericau': 'kericau',
'berkericauan': 'kericau',
'mengerih': 'kerih',
'mengerihkan': 'kerih',
'kerikan': 'kerik',
'kerik api': 'kerik',
'mengerikil': 'kerikil',
'mengerikili': 'kerikil',
'pengerikilan': 'kerikil',
'mengerikiti': 'kerikit',
'berkering': 'kering',
'berkeringan': 'kering',
'pengering': 'kering',
'pengeringnya': 'kering',
'pengeringan': 'kering',
'mengering': 'kering',
'mengeringnya': 'kering',
'mengeringkan': 'kering',
'mengeringkannya': 'kering',
'mengeringan': 'kering',
'mengeringi': 'kering',
'mengeringinya': 'kering',
'kekeringan': 'kering',
'kekeringannya': 'kering',
'pengeringannya': 'kering',
'pengeringanan': 'kering',
'berkering-kering': 'kering',
'kering-kering air': 'kering',
'peringanan': 'ringan',
'keringanan': 'ringan',
'keringanannya': 'ringan',
'keringananlah': 'ringan',
'meringankan': 'ringan',
'meringankannya': 'ringan',
'meringankanlah': 'ringan',
'memperingankan': 'ringan',
'mengerinjang': 'kerinjang',
'mengerip': 'kerip',
'berkeriput': 'keriput',
'berkeris': 'keris',
'mengeris': 'keris',
'perkerisan': 'keris',
'perisau': 'risau',
'merisau': 'risau',
'merisaukan': 'risau',
'merisaukannya': 'risau',
'kerisauan': 'risau',
'kerisauannya': 'risau',
'kerisikan': 'kerisik',
'berkerisik': 'kerisik',
'mengerisik': 'kerisik',
'mengerising': 'kerising',
'mengerit': 'kerit',
'mengeritkan': 'kerit',
'berkeritik-keritik': 'keritik',
'mengeriting': 'keriting',
'mengeritingnya': 'keriting',
'mengeritingkannya': 'keriting',
'mengeritingi': 'keriting',
'pengeritingan': 'keriting',
'mengeritingkan': 'keriting',
'berkeriuk': 'keriuk',
'mengerjang': 'kerjang',
'mengerjap': 'kerjap',
'mengerjapkan': 'kerjap',
'mengerjap-ngerjap': 'kerjap',
'dikerkah': 'kerkah',
'mengerkah': 'kerkah',
'mengerkau': 'kerkau',
'tekerlap': 'kerlap',
'mengerlap': 'kerlap',
'bekerlapan': 'kerlap',
'kerlingan': 'kerling',
'mengerling': 'kerling',
'mengerlingkan': 'kerling',
'mengerlingku': 'kerling',
'mengerling-ngerling': 'kerling',
'sekerlip': 'kerlip',
'bekerlip': 'kerlip',
'bekerlipan': 'kerlip',
'mengerlip': 'kerlip',
'kermian': 'kermi',
'mengernai': 'kernai',
'mengerneti': 'kernet',
'mengernyih': 'kernyih',
'mengernying': 'kernying',
'mengernyit': 'kernyit',
'mengernyitkan': 'kernyit',
'bekernyut': 'kernyut',
'mengernyut': 'kernyut',
'mengernyutkan': 'kernyut',
'bekernyutan': 'kernyut',
'kerobak-kerobik': 'kerobak',
'kerobak-kerabit': 'kerobak',
'kerobak-kerobek': 'kerobak',
'kerobat-kerabit': 'kerobat',
'mengerobek': 'kerobek',
'kerokan': 'kerok',
'mengerok': 'kerok',
'mengeroki': 'kerok',
'mengerokoti': 'kerokot',
'pengerokotan': 'kerokot',
'keroncongan': 'keroncong',
'berkeroncongan': 'keroncong',
'mengeroncongkan': 'keroncong',
'kerong-kerong': 'kerong',
'rongkongan': 'rongos',
'kerongkongan': 'rongkong',
'kerongkongannya': 'rongkong',
'kerongkonganku': 'rongkong',
'mengeropeng': 'keropeng',
'sekeropok': 'keropok',
'mengerosi': 'kerosi',
'mengerosong': 'kerosong',
'kerang-kerot': 'kerot',
'berkerotak': 'kerotak',
'keroyokan': 'keroyok',
'keroyokanlah': 'keroyok',
'pengeroyok': 'keroyok',
'pengeroyoknya': 'keroyok',
'pengeroyokkan': 'keroyok',
'pengeroyokan': 'keroyok',
'mengeroyok': 'keroyok',
'mengeroyoknya': 'keroyok',
'mengeroyokan': 'keroyok',
'pengeroyokannya': 'keroyok',
'mengerpus': 'kerpus',
'bekersik': 'kersik',
'tekersik': 'kersik',
'mengersik': 'kersik',
'bekertak': 'kertak',
'kertak-kertuk': 'kertak',
'bekertak-kertak': 'kertak',
'mengertak-ngertakkan': 'kertak',
'mengertangkan': 'kertang',
'kertap-kertap': 'kertap',
'kerubinan': 'kerubin',
'kerubungan': 'kerubung',
'berkerubung': 'kerubung',
'mengerubungi': 'kerubung',
'mengerubunginya': 'kerubung',
'mengerubungiku': 'kerubung',
'mengerubuti': 'kerubut',
'mengerubutinya': 'kerubut',
'mengerucut': 'kerucut',
'mengerucutnya': 'kerucut',
'mengerucutlah': 'kerucut',
'mengerucutkan': 'kerucut',
'mengerucutkannya': 'kerucut',
'berkerudung': 'kerudung',
'mengerudungi': 'kerudung',
'merugi': 'rugi',
'meruginya': 'rugi',
'merugilah': 'rugi',
'merugikan': 'rugi',
'merugikannya': 'rugi',
'merugian': 'rugi',
'berugi': 'rugi',
'berugikan': 'rugi',
'kerugian': 'rugi',
'kerugiannya': 'rugi',
'kerugianku': 'rugi',
'kerugianmu': 'rugi',
'merugikanku': 'rugi',
'merugikanmu': 'rugi',
'mengeruh': 'keruh',
'mengeruhkan': 'keruh',
'berkeruh': 'keruh',
'kekeruhan': 'keruh',
'kekeruhannya': 'keruh',
'berkeruit-keruit': 'keruit',
'mengeruk': 'keruk',
'mengeruknya': 'keruk',
'mengeruki': 'keruk',
'mengerukan': 'keruk',
'pengerukan': 'keruk',
'pengerukannya': 'keruk',
'mengerukkan': 'keruk',
'mengerukut': 'kerukut',
'mengerukutkan': 'kerukut',
'mengerul': 'kerul',
'mengerumit': 'kerumit',
'berkerumuk': 'kerumuk',
'mengerumukkan': 'kerumuk',
'mengerumus': 'kerumus',
'meruncing': 'runcing',
'meruncingnya': 'runcing',
'meruncingkan': 'runcing',
'keruncingan': 'runcing',
'memperuncing': 'runcing',
'meruntuh': 'runtuh',
'meruntuhnya': 'runtuh',
'meruntuhkan': 'runtuh',
'meruntuhkannya': 'runtuh',
'meruntuhan': 'runtuh',
'runtuhan': 'runtuh',
'runtuhannya': 'runtuh',
'reruntuhan': 'runtuh',
'reruntuhannya': 'runtuh',
'keruntuhan': 'runtuh',
'keruntuhannya': 'runtuh',
'mengeruntungkan': 'keruntung',
'berkerunyut': 'kerunyut',
'terkerunyut': 'kerunyut',
'kerupukan': 'kerupuk',
'mengerutak': 'kerutak',
'berkeruyuk': 'keruyuk',
'mengesah': 'kesah',
'mengesahkan': 'sah',
'mengesahkannya': 'sah',
'mengesahan': 'kesah',
'mengesakkan': 'kesak',
'penyakit': 'sakit',
'penyakitnya': 'sakit',
'penyakitlah': 'sakit',
'penyakitkan': 'sakit',
'penyakiti': 'sakit',
'penyakitan': 'sakit',
'penyakitku': 'sakit',
'penyakitmu': 'sakit',
'menyakiti': 'sakit',
'menyakitinya': 'sakit',
'menyakitii': 'sakit',
'menyakitiku': 'sakit',
'menyakitimu': 'sakit',
'kesakitan': 'sakit',
'kesakitannya': 'sakit',
'kesakitanku': 'sakit',
'pesakitan': 'sakit',
'pesakitannya': 'sakit',
'menyakitkan': 'sakit',
'menyakitkannya': 'sakit',
'menyakitkanku': 'sakit',
'mempersakiti': 'sakit',
'berpenyakitan': 'sakit',
'sakit-sakitan': 'sakit',
'bersakit-sakit': 'sakit',
'bersakit-sakitan': 'sakit',
'kesaksamaan': 'saksama',
'kesaktian': 'sakti',
'kesaktiannya': 'sakti',
'menyaktikan': 'sakti',
'kekesalan': 'kesal',
'kekesalannya': 'kesal',
'mengesalkan': 'kesal',
'mengesalkannya': 'kesal',
'menyalah': 'salah',
'menyalahkan': 'salah',
'menyalahkannya': 'salah',
'menyalahi': 'salah',
'menyalahan': 'salah',
'bersalah': 'salah',
'bersalahnya': 'salah',
'bersalahlah': 'salah',
'bersalahan': 'salah',
'tersalah': 'salah',
'kesalahan': 'salah',
'kesalahannya': 'salah',
'kesalahanan': 'salah',
'kesalahanku': 'salah',
'kesalahanmu': 'salah',
'salah-salah': 'salah',
'salah-salahnya': 'salah',
'salah-salahan': 'salah',
'salah-salahku': 'salah',
'menyalahkankan': 'salah',
'menyalahkanku': 'salah',
'menyalahkanmu': 'salah',
'mempersalahkan': 'salah',
'mempersalahkannya': 'salah',
'bersalah-salahan': 'salah',
'berkesam': 'kesam',
'samaran': 'samar',
'samarannya': 'samar',
'penyamar': 'samar',
'penyamarlah': 'samar',
'penyamaran': 'samar',
'menyamar': 'samar',
'menyamarnya': 'samar',
'menyamarkan': 'samar',
'menyamarkannya': 'samar',
'kesamaran': 'samar',
'penyamarannya': 'samar',
'samar-samar': 'samar',
'terkesan': 'kesan',
'terkesannya': 'kesan',
'berkesan': 'kesan',
'berkesannya': 'kesan',
'mengesan': 'kesan',
'mengesankan': 'kesan',
'mengesankannya': 'kesan',
'mengesani': 'kesan',
'mengesang': 'kesang',
'penyangsi': 'sangsi',
'kesangsian': 'sangsi',
'kesangsiannya': 'sangsi',
'menyangsikan': 'sangsi',
'menyangsikannya': 'sangsi',
'kesasar': 'sasar',
'kesasaran': 'sasar',
'sasaran': 'sasar',
'sasarannya': 'sasar',
'sasaranan': 'sasar',
'sasaranku': 'sasar',
'menyasar': 'sasar',
'menyasarnya': 'sasar',
'menyasarkan': 'sasar',
'menyasarkannya': 'sasar',
'tersasar': 'sasar',
'tersasarnya': 'sasar',
'tersasarkan': 'sasar',
'sasarannyakan': 'sasar',
'bersasaran': 'sasar',
'pengesat': 'kesat',
'mengesat': 'kesat',
'sayangkan': 'sayang',
'penyayang': 'sayang',
'penyayangnya': 'sayang',
'penyayanglah': 'sayang',
'menyayang': 'sayang',
'menyayangkan': 'sayang',
'menyayangkannya': 'sayang',
'menyayangi': 'sayang',
'menyayangan': 'sayang',
'menyayanginya': 'sayang',
'menyayangiku': 'sayang',
'menyayangimu': 'sayang',
'kesayangan': 'sayang',
'kesayangannya': 'sayang',
'kesayanganku': 'sayang',
'kesayanganmu': 'sayang',
'menyayangkankan': 'sayang',
'tersayang': 'sayang',
'sedapan': 'sedap',
'penyedap': 'sedap',
'penyedapnya': 'sedap',
'penyedapan': 'sedap',
'kesedapan': 'sedap',
'menyedapkan': 'sedap',
'sedap-sedapan': 'sedap',
'penyegar': 'segar',
'penyegaran': 'segar',
'kesegaran': 'segar',
'kesegarannya': 'segar',
'penyegarannya': 'segar',
'menyegarkan': 'segar',
'menyegarkannya': 'segar',
'menyegarkankan': 'segar',
'mempersegar': 'segar',
'penyehat': 'sehat',
'penyehatan': 'sehat',
'kesehatan': 'sehat',
'kesehatannya': 'sehat',
'kesehatanlah': 'sehat',
'kesehatani': 'sehat',
'kesehatanan': 'sehat',
'kesehatanku': 'sehat',
'kesehatanmu': 'sehat',
'penyehatannya': 'sehat',
'menyehatkan': 'sehat',
'menyehatkannya': 'sehat',
'mengesek': 'kesek',
'mengesekkan': 'kesek',
'mengesekan': 'kesek',
'mengesel': 'kesel',
'selamatan': 'selamat',
'selamatannya': 'selamat',
'penyelamat': 'selamat',
'penyelamatnya': 'selamat',
'penyelamatkan': 'selamat',
'penyelamatan': 'selamat',
'penyelamatku': 'selamat',
'keselamatan': 'selamat',
'keselamatannya': 'selamat',
'keselamatanlah': 'selamat',
'keselamatanan': 'selamat',
'keselamatanku': 'selamat',
'keselamatanmu': 'selamat',
'menyelamati': 'selamat',
'menyelamatinya': 'selamat',
'menyelamatikan': 'selamat',
'menyelamatiku': 'selamat',
'berselamatan': 'selamat',
'penyelamatannya': 'selamat',
'penyelamatanan': 'selamat',
'penyelamatanku': 'selamat',
'penyelamatanmu': 'selamat',
'penyelamatan-mu': 'selamat',
'menyelamatkan': 'selamat',
'menyelamatkannya': 'selamat',
'menyelamatkanku': 'selamat',
'menyelamatkanmu': 'selamat',
'menyempat': 'sempat',
'menyempatkan': 'sempat',
'menyempati': 'sempat',
'menyempatan': 'sempat',
'kesempatan': 'sempat',
'kesempatannya': 'sempat',
'kesempatanlah': 'sempat',
'kesempatanan': 'sempat',
'kesempatanku': 'sempat',
'kesempatanmu': 'sempat',
'berkesempatan': 'sempat',
'sempat-sempatnya': 'sempat',
'sempitan': 'sempit',
'menyempit': 'sempit',
'menyempitnya': 'sempit',
'menyempitkan': 'sempit',
'menyempitkannya': 'sempit',
'kesempitan': 'sempit',
'penyempitan': 'sempit',
'penyempitannya': 'sempit',
'persempitan': 'sempit',
'mempersempit': 'sempit',
'mempersempitnya': 'sempit',
'bersempit-sempit': 'sempit',
'kesempurnaan': 'sempurna',
'kesempurnaannya': 'sempurna',
'penyempurnaan': 'sempurna',
'penyempurnaannya': 'sempurna',
'menyempurnakan': 'sempurna',
'menyempurnakannya': 'sempurna',
'menyempurnakanlah': 'sempurna',
'kesengsaraan': 'sengsara',
'kesengsaraannya': 'sengsara',
'menyengsarakan': 'sengsara',
'menyengsarakannya': 'sengsara',
'kesenyapan': 'senyap',
'menyepi': 'sepi',
'menyepikan': 'sepi',
'penyepi': 'sepi',
'penyepian': 'sepi',
'kesepian': 'sepi',
'kesepiannya': 'sepi',
'kesepianmu': 'sepi',
'bersepi-sepi': 'sepi',
'berseragam': 'seragam',
'berseragamnya': 'seragam',
'berseragamkan': 'seragam',
'berseragaman': 'seragam',
'keseragaman': 'seragam',
'keseragamannya': 'seragam',
'penyeragaman': 'seragam',
'penyeragamannya': 'seragam',
'menyeragamkan': 'seragam',
'menyeragamkannya': 'seragam',
'keserakahan': 'serakah',
'keserakahannya': 'serakah',
'keserakahanku': 'serakah',
'keserakahanmu': 'serakah',
'keserasian': 'serasi',
'keserasiannya': 'serasi',
'penyerasian': 'serasi',
'menyerasikan': 'serasi',
'menyerasikannya': 'serasi',
'keseriusan': 'serius',
'keseriusannya': 'serius',
'keseriusanmu': 'serius',
'menyeriusi': 'serius',
'menyeriusinya': 'serius',
'menyerong': 'serong',
'menyerongkan': 'serong',
'keserongan': 'serong',
'serong-menyerong': 'serong',
'mengeset': 'set',
'berkeset': 'keset',
'terkesiap': 'kesiap',
'kesik-kesik': 'kesik',
'terkesima': 'kesima',
'terkesimanya': 'kesima',
'simpulan': 'simpul',
'simpulannya': 'simpul',
'menyimpul': 'simpul',
'menyimpulkan': 'simpul',
'menyimpulkannya': 'simpul',
'menyimpulan': 'simpul',
'tersimpul': 'simpul',
'tersimpulkan': 'simpul',
'kesimpulan': 'simpul',
'kesimpulannya': 'simpul',
'kesimpulanku': 'simpul',
'berkesimpulan': 'simpul',
'kesinisan': 'sinis',
'kesinisannya': 'sinis',
'mengesip': 'kesip',
'berkesiur': 'kesiur',
'menyombong': 'sombong',
'menyombongkan': 'sombong',
'menyombongkannya': 'sombong',
'penyombong': 'sombong',
'bersombong': 'sombong',
'menyombongi': 'sombong',
'kesombongan': 'sombong',
'kesombongannya': 'sombong',
'menyopani': 'sopan',
'kesopanan': 'sopan',
'kesopanannya': 'sopan',
'menyopankan': 'sopan',
'bersopan-sopan': 'sopan',
'penyubur': 'subur',
'penyuburan': 'subur',
'kesuburan': 'subur',
'kesuburannya': 'subur',
'menyuburkan': 'subur',
'menyuburkannya': 'subur',
'sesuka': 'suka',
'sesukanya': 'suka',
'sesukaku': 'suka',
'sesukamu': 'suka',
'sukaan': 'suka',
'sukaannya': 'suka',
'kesukaan': 'suka',
'kesukaannya': 'suka',
'kesukaanku': 'suka',
'kesukaanmu': 'suka',
'menyukai': 'suka',
'menyukainya': 'suka',
'menyukaiku': 'suka',
'menyukaimu': 'suka',
'suka-suka': 'suka',
'suka-sukanya': 'suka',
'suka-sukaan': 'suka',
'menyukakan': 'suka',
'sesuka-suka': 'suka',
'sesuka-sukanya': 'suka',
'bersuka-suka': 'suka',
'bersuka-sukaan': 'suka',
'kesukaran': 'sukar',
'kesukarannya': 'sukar',
'menyukarkan': 'sukar',
'menyukarkannya': 'sukar',
'mempersukar': 'sukar',
'sesuku': 'suku',
'sesukunya': 'suku',
'bersuku': 'suku',
'pesukuan': 'suku',
'kesukuan': 'suku',
'kesukuannya': 'suku',
'persukuan': 'suku',
'sepersukuan': 'suku',
'bersuku-suku': 'suku',
'penyulit': 'sulit',
'penyulitnya': 'sulit',
'penyulitan': 'sulit',
'kesulitan': 'sulit',
'kesulitannya': 'sulit',
'kesulitanlah': 'sulit',
'kesulitanan': 'sulit',
'kesulitanku': 'sulit',
'kesulitanmu': 'sulit',
'mempersulit': 'sulit',
'mempersulitnya': 'sulit',
'mempersulitkan': 'sulit',
'menyulitkan': 'sulit',
'menyulitkannya': 'sulit',
'menyulitkanku': 'sulit',
'menyulitkanmu': 'sulit',
'mengesumba': 'kesumba',
'menyunyi': 'sunyi',
'bersunyi': 'sunyi',
'kesunyian': 'sunyi',
'kesunyiannya': 'sunyi',
'bersunyi-sunyi': 'sunyi',
'mengesup': 'kesup',
'menyuram': 'suram',
'menyuramkan': 'suram',
'kesuraman': 'suram',
'kesuramannya': 'suram',
'suram-suram': 'suram',
'bersusila': 'susila',
'kesusilaan': 'susila',
'kesusilaannya': 'susila',
'terkesut-kesut': 'kesut',
'ketabahan': 'tabah',
'ketabahannya': 'tabah',
'menabahkan': 'tabah',
'penagih': 'tagih',
'penagihnya': 'tagih',
'penagihan': 'tagih',
'tagihan': 'tagih',
'tagihannya': 'tagih',
'tagihanmu': 'tagih',
'menagih': 'tagih',
'menagihnya': 'tagih',
'menagihkan': 'tagih',
'menagihkannya': 'tagih',
'tertagih': 'tagih',
'tertagihnya': 'tagih',
'tertagihkan': 'tagih',
'penagihannya': 'tagih',
'ketagihan': 'tagih',
'ketagihannya': 'tagih',
'berketai-ketai': 'ketai',
'menakut': 'takut',
'menakutnya': 'takut',
'menakutkan': 'takut',
'menakutkannya': 'takut',
'menakuti': 'takut',
'menakutan': 'takut',
'penakut': 'takut',
'penakutkan': 'takut',
'menakutinya': 'takut',
'ketakutan': 'takut',
'ketakutannya': 'takut',
'ketakutanlah': 'takut',
'ketakutannyalah': 'takut',
'ketakutanku': 'takut',
'ketakutanmu': 'takut',
'menakutkanlah': 'takut',
'menakutkanku': 'takut',
'takut-takut': 'takut',
'takut-takutnya': 'takut',
'takut-takuti': 'takut',
'mempertakut': 'takut',
'berketakutan': 'takut',
'takut-takutan': 'takut',
'menakut-nakuti': 'takut',
'menakut-nakutinya': 'takut',
'menakut-nakutii': 'takut',
'menakut-nakutimu': 'takut',
'mengetam': 'ketam',
'pengetam': 'ketam',
'pengetaman': 'ketam',
'berketam': 'ketam',
'mengetamkan': 'ketam',
'ketamakan': 'tamak',
'ketamakannya': 'tamak',
'ketangkasan': 'tangkas',
'ketangkasannya': 'tangkas',
'ketangkasanlah': 'tangkas',
'ketangkasanan': 'tangkas',
'menangkaskan': 'tangkas',
'mengetap': 'tap',
'berketap-ketap': 'ketap-ketap',
'berketar-ketar': 'ketar',
'pengetatan': 'ketat',
'pengetatannya': 'ketat',
'memperketat': 'ketat',
'memperketatnya': 'ketat',
'mengetatkan': 'ketat',
'mengetatkannya': 'ketat',
'ketawa': 'tawa',
'ketawanya': 'tawa',
'ketawalah': 'tawa',
'ketawai': 'tawa',
'ketawaan': 'tawa',
'ketawamu': 'tawa',
'tertawa': 'tawa',
'tertawanya': 'tawa',
'tertawalah': 'tawa',
'tertawakan': 'tawa',
'tertawai': 'tawa',
'tertawaan': 'tawa',
'tertawamu': 'tawa',
'menertawai': 'tawa',
'menertawainya': 'tawa',
'menertawaiku': 'tawa',
'penertawaan': 'tawa',
'menertawakan': 'tawa',
'menertawakannya': 'tawa',
'menertawakanku': 'tawa',
'menebal': 'tebal',
'menebalnya': 'tebal',
'menebalkan': 'tebal',
'menebalkannya': 'tebal',
'setebal': 'tebal',
'ketebalan': 'tebal',
'ketebalannya': 'tebal',
'tebal bibir': 'tebal',
'mempertebal': 'tebal',
'mempertebalnya': 'tebal',
'mempertebalkan': 'tebal',
'penegang': 'tegang',
'penegangan': 'tegang',
'menegang': 'tegang',
'menegangnya': 'tegang',
'menegangkan': 'tegang',
'menegangkannya': 'tegang',
'tegangan': 'tegang',
'tegangannya': 'tegang',
'menegangi': 'tegang',
'ketegangan': 'tegang',
'ketegangannya': 'tegang',
'bersitegang': 'tegang',
'bersitegangnya': 'tegang',
'bersitegangan': 'tegang',
'ketegaran': 'tegar',
'ketegarannya': 'tegar',
'menegarkan': 'tegar',
'berteguh': 'teguh',
'peneguhan': 'teguh',
'keteguhan': 'teguh',
'keteguhannya': 'teguh',
'bersiteguh': 'teguh',
'meneguhkan': 'teguh',
'meneguhkannya': 'teguh',
'memperteguh': 'teguh',
'memperteguhkan': 'teguh',
'berteguh-teguh': 'teguh',
'berteguh-teguhan': 'teguh',
'seketek': 'ketek',
'mengeteki': 'ketek',
'mengetemui': 'ketemu',
'mengetemukan': 'ketemu',
'penenang': 'tenang',
'penenangnya': 'tenang',
'penenangkan': 'tenang',
'penenangan': 'tenang',
'menenang': 'tenang',
'menenangnya': 'tenang',
'menenangkan': 'tenang',
'menenangkannya': 'tenang',
'menenangi': 'tenang',
'menenangan': 'tenang',
'ketenangan': 'tenang',
'ketenangannya': 'tenang',
'ketenanganku': 'tenang',
'menenangkanku': 'tenang',
'menenangkanmu': 'tenang',
'bertenang-tenang': 'tenang',
'ketengan': 'keteng',
'ketengannya': 'keteng',
'ketenganan': 'keteng',
'seketeng': 'keteng',
'mengeteng': 'keteng',
'mengetengi': 'keteng',
'mengetengkan': 'keteng',
'terlanjur': 'lanjur',
'melanjurkan': 'lanjur',
'keterlanjuran': 'lanjur',
'bertertib': 'tertib',
'ketertiban': 'tertib',
'ketertibannya': 'tertib',
'penertiban': 'tertib',
'penertibannya': 'tertib',
'penertibankan': 'tertib',
'menertibkan': 'tertib',
'menertibkannya': 'tertib',
'mengetesi': 'ketes',
'keteteran': 'keteter',
'mengeti': 'keti',
'mengetikan': 'tik',
'keti-keti': 'keti',
'berketi-keti': 'keti',
'ketiga': 'tiga',
'ketiganya': 'tiga',
'ketigalah': 'tiga',
'ketigakan': 'tiga',
'ketigaku': 'tiga',
'meniga': 'tiga',
'bertiga': 'tiga',
'bertigalah': 'tiga',
'bertigaan': 'tiga',
'pertiga': 'tiga',
'pertiganya': 'tiga',
'pertigaan': 'tiga',
'pertigaanan': 'tiga',
'sepertiga': 'tiga',
'sepertiganya': 'tiga',
'ketiganyanya': 'tiga',
'mempertiga': 'tiga',
'tiga-tiganya': 'tiga',
'tiga-tiganyanya': 'tiga',
'ketiga-tiganya': 'tiga',
'seketika': 'ketika',
'seketikanya': 'ketika',
'seketil': 'ketil',
'mengetil': 'ketil',
'berketil-ketil': 'ketil',
'mengeting': 'keting',
'petinggi': 'tinggi',
'petingginya': 'tinggi',
'meninggi': 'tinggi',
'meningginya': 'tinggi',
'meninggikan': 'tinggi',
'meninggikannya': 'tinggi',
'tertinggi': 'tinggi',
'tertingginya': 'tinggi',
'tertinggilah': 'tinggi',
'tertinggimu': 'tinggi',
'peninggian': 'tinggi',
'ketinggian': 'tinggi',
'ketinggiannya': 'tinggi',
'mempertinggi': 'tinggi',
'seketip': 'ketip',
'pengetip': 'ketip',
'mengetip': 'tip',
'mengetipnya': 'tip',
'ketap-ketip': 'ketip',
'berketap-ketip': 'ketip',
'mengetis': 'ketis',
'ketitiran': 'ketitir',
'ketokan': 'ketok',
'mengetok': 'ketok',
'mengetoknya': 'ketok',
'mengetokkan': 'ketok',
'mengetokan': 'ketok',
'pengetok': 'ketok',
'pengetokan': 'ketok',
'ketololan': 'tolol',
'ketololannya': 'tolol',
'ketololanmu': 'tolol',
'mengetrek': 'trek',
'berketua': 'ketua',
'mengetuai': 'ketua',
'mengetuainya': 'ketua',
'pengetul': 'ketul',
'mengetulkan': 'ketul',
'berketul-ketul': 'ketul',
'ketulenan': 'tulen',
'ketulian': 'tuli',
'ketuliannya': 'tuli',
'menulikan': 'tuli',
'tuli-tuli': 'tuli',
'tumbuhan': 'tumbuh',
'tumbuhannya': 'tumbuh',
'tumbuhanan': 'tumbuh',
'penumbuh': 'tumbuh',
'penumbuhkan': 'tumbuh',
'penumbuhan': 'tumbuh',
'menumbuh': 'tumbuh',
'menumbuhkan': 'tumbuh',
'menumbuhkannya': 'tumbuh',
'menumbuhan': 'tumbuh',
'bertumbuh': 'tumbuh',
'bertumbuhnya': 'tumbuh',
'bertumbuhan': 'tumbuh',
'menumbuhi': 'tumbuh',
'ketumbuhan': 'tumbuh',
'tetumbuhan': 'tumbuh',
'pertumbuhan': 'tumbuh',
'pertumbuhannya': 'tumbuh',
'bertumbuhannya': 'tumbuh',
'mempertumbuhkan': 'tumbuh',
'tumbuh-tumbuhan': 'tumbuh',
'tumbuh-tumbuhannya': 'tumbuh',
'tumbuh-tumbuhanan': 'tumbuh',
'berketur': 'ketur',
'penurun': 'turun',
'penurunnya': 'turun',
'penurunkan': 'turun',
'penurunan': 'turun',
'turunan': 'turun',
'turunannya': 'turun',
'turunanan': 'turun',
'turunannyalah': 'turun',
'menurun': 'turun',
'menurunnya': 'turun',
'menurunlah': 'turun',
'menurunkan': 'turun',
'menurunkannya': 'turun',
'menuruni': 'turun',
'menurunan': 'turun',
'menuruninya': 'turun',
'berturun': 'turun',
'berturunan': 'turun',
'keturunan': 'turun',
'keturunannya': 'turun',
'keturunanan': 'turun',
'keturunannyalah': 'turun',
'keturunanku': 'turun',
'penurunannya': 'turun',
'penurunanan': 'turun',
'menurunkanlah': 'turun',
'menurunkankan': 'turun',
'menurunkanku': 'turun',
'menurunkanmu': 'turun',
'turun-temurun': 'turun',
'turun-temurunnya': 'turun',
'memperturunkan': 'turun',
'unggulan': 'unggul',
'unggulannya': 'unggul',
'keunggulan': 'unggul',
'keunggulannya': 'unggul',
'keunggulani': 'unggul',
'keunggulanmu': 'unggul',
'mengungguli': 'unggul',
'mengunggulinya': 'unggul',
'unggul-mengungguli': 'unggul',
'keunikan': 'unik',
'keunikannya': 'unik',
'keusahawanan': 'usahawan',
'mengusang': 'usang',
'keusangan': 'usang',
'keusangannya': 'usang',
'keuskupan': 'uskup',
'keuskupannya': 'uskup',
'seutuh': 'utuh',
'seutuhnya': 'utuh',
'seutuhkan': 'utuh',
'keutuhan': 'utuh',
'keutuhannya': 'utuh',
'keseutuhan': 'utuh',
'pengutuhan': 'utuh',
'mengutuhkan': 'utuh',
'sewajar': 'wajar',
'sewajarnya': 'wajar',
'sewajarnyalah': 'wajar',
'kewajaran': 'wajar',
'kewajarannya': 'wajar',
'berwajib': 'wajib',
'berwajibnya': 'wajib',
'berwajiblah': 'wajib',
'berwajiban': 'wajib',
'kewajiban': 'wajib',
'kewajibannya': 'wajib',
'kewajibanku': 'wajib',
'kewajibanmu': 'wajib',
'sewajibnya': 'wajib',
'mewajibkan': 'wajib',
'mewajibkannya': 'wajib',
'berkewajiban': 'wajib',
'kewalahan': 'walah',
'kewalahannya': 'walah',
'kewalahanan': 'walah',
'mewangi': 'wangi',
'mewangikan': 'wangi',
'mewangian': 'wangi',
'pewangi': 'wangi',
'pewanginya': 'wangi',
'kewangian': 'wangi',
'wewangian': 'wangi',
'wewangiannya': 'wangi',
'wangi-wangian': 'wangi',
'wangi-wangiannya': 'wangi',
'kewangi-wangian': 'wangi',
'kewanitaan': 'wanita',
'kewanitaannya': 'wanita',
'kewanitaanku': 'wanita',
'kewarasan': 'waras',
'kewarasannya': 'waras',
'kewarasanku': 'waras',
'kewartawanan': 'wartawan',
'kewartawanannya': 'wartawan',
'mengewuhkan': 'kewuh',
'menzalimi': 'zalim',
'menzaliminya': 'zalim',
'kezaliman': 'zalim',
'kezalimannya': 'zalim',
'menzalimkan': 'zalim',
'mengkhalayak': 'khalayak',
'berkhalwat': 'khalwat',
'berkhamir': 'khamir',
'kekhasan': 'khas',
'kekhasannya': 'khas',
'kekhasanmu': 'khas',
'mengkhaskan': 'khas',
'khataman': 'khatam',
'khatamannya': 'khatam',
'mengkhatamkan': 'khatam',
'kekhawatiran': 'khawatir',
'kekhawatirannya': 'khawatir',
'kekhawatiranku': 'khawatir',
'mengkhawatirkan': 'khawatir',
'mengkhawatirkannya': 'khawatir',
'mengkhawatirkanku': 'khawatir',
'mengkhawatirkanmu': 'khawatir',
'khayalan': 'khayal',
'khayalannya': 'khayal',
'khayalanku': 'khayal',
'berkhayal': 'khayal',
'berkhayalnya': 'khayal',
'mengkhayal': 'khayal',
'mengkhayalkan': 'khayal',
'pengkhayal': 'khayal',
'pengkhayalan': 'khayal',
'berkhianat': 'khianat',
'berkhianatnya': 'khianat',
'mengkhianat': 'khianat',
'mengkhianati': 'khianat',
'pengkhianat': 'khianat',
'pengkhianatnya': 'khianat',
'pengkhianatlah': 'khianat',
'pengkhianatan': 'khianat',
'mengkhianatinya': 'khianat',
'mengkhianatiku': 'khianat',
'mengkhianatimu': 'khianat',
'pengkhianatannya': 'khianat',
'kekhilafan': 'khilaf',
'kekhilafannya': 'khilaf',
'khitanan': 'khitan',
'berkhitan': 'khitan',
'mengkhitan': 'khitan',
'mengkhitankan': 'khitan',
'berkhotbah': 'khotbah',
'berkhotbahnya': 'khotbah',
'pengkhotbah': 'khotbah',
'pengkhotbahnya': 'khotbah',
'pengkhotbahan': 'khotbah',
'mengkhotbahkan': 'khotbah',
'terkhusus': 'khusus',
'terkhususnya': 'khusus',
'kekhususan': 'khusus',
'kekhususannya': 'khusus',
'mengkhusus': 'khusus',
'mengkhususnya': 'khusus',
'mengkhususkan': 'khusus',
'mengkhususkannya': 'khusus',
'pengkhususan': 'khusus',
'kia-kia': 'kia',
'kia-kiai': 'kia',
'kia bunga sambu': 'kia',
'mengiah': 'kiah',
'pengiah': 'kiah',
'mengiahkan': 'kiah',
'pengiah sepatu': 'kiah',
'kiak-kiak': 'kiak',
'kialan': 'kial',
'pengial': 'kial',
'berkial': 'kial',
'perkialan': 'kial',
'kial-kial': 'kial',
'mengialkan': 'kial',
'terkial-kial': 'kial',
'berkial-kial': 'kial',
'sekian': 'kian',
'sekianlah': 'kian',
'sekiankan': 'kian',
'berkian-kian': 'kian',
'kiasan': 'kias',
'kiasannya': 'kias',
'kiasanlah': 'kias',
'berkias': 'kias',
'mengias': 'kias',
'mengiaskan': 'kias',
'mengiasi': 'kias',
'pengias': 'kias',
'pengiasan': 'kias',
'berkias-kias': 'kias',
'berkias-kiasan': 'kias',
'mengiat': 'kiat',
'mengiatkan': 'kiat',
'berkiat': 'kiat',
'berkiatan': 'kiat',
'kibasan': 'kibas',
'mengibas': 'kibas',
'mengibasnya': 'kibas',
'mengibaskan': 'kibas',
'mengibaskannya': 'kibas',
'mengibas-ngibas': 'kibas',
'mengibas-ngibaskan': 'kibas',
'berkiblat': 'kiblat',
'berkiblatnya': 'kiblat',
'mengiblatkan': 'kiblat',
'pengibul': 'kibul',
'pengibulan': 'kibul',
'terkibuli': 'kibul',
'mengibuli': 'kibul',
'mengibulinya': 'kibul',
'terkicu': 'kicu',
'pengicu': 'kicu',
'mengicu': 'kicu',
'pengicuan': 'kicu',
'berkicuh': 'kicuh',
'berkicut': 'kicut',
'kidungan': 'kidung',
'mengidung': 'kidung',
'mengidungkan': 'kidung',
'terkijai-kijai': 'kijai',
'mengijing': 'kijing',
'terkikih-kikih': 'kikih',
'mengikik': 'kikik',
'berkikikan': 'kikik',
'terkikik-kikik': 'kikik',
'kikisan': 'kikis',
'terkikis': 'kikis',
'terkikisnya': 'kikis',
'pengikis': 'kikis',
'pengikisan': 'kikis',
'mengikis': 'kikis',
'mengikisnya': 'kikis',
'mengikiskan': 'kikis',
'mengikisi': 'kikis',
'mengikisan': 'kikis',
'pengikisannya': 'kikis',
'kekikukan': 'kikuk',
'kekikukannya': 'kikuk',
'mengilah': 'kilah',
'berkilah': 'kilah',
'berkilah-kilah': 'kilah',
'mengilah-ngilahkan': 'kilah',
'mengilan': 'kilan',
'terkilan': 'kilan',
'kilangan': 'kilang',
'mengilang': 'kilang',
'mengilangnya': 'kilang',
'mengilangkan': 'kilang',
'pengilang': 'kilang',
'pengilangan': 'kilang',
'perkilangan': 'kilang',
'pengilangannya': 'kilang',
'sekilap': 'kilap',
'mengilap': 'kilap',
'mengilapnya': 'kilap',
'mengilapkan': 'kilap',
'berkilap': 'kilap',
'berkilapnya': 'kilap',
'pengilapan': 'kilap',
'berkilap-kilap': 'kilap',
'sekilas': 'kilas',
'sekilasnya': 'kilas',
'sekilasi': 'kilas',
'terkilas': 'kilas',
'kili-kili': 'kili',
'kilik-kilik': 'kilikan',
'mengilik-ngilik': 'kilikan',
'kiliran': 'kilir',
'mengilir': 'kilir',
'terkilir': 'kilir',
'terkilirnya': 'kilir',
'kiloan': 'kilo',
'kiloannya': 'kilo',
'mengilo': 'kilo',
'mengilokan': 'kilo',
'berkilo-kilo': 'kilo',
'terkimah': 'kimah',
'mengimbah': 'kimbah',
'berkimbang-kimbang': 'kimbang',
'mengimpal': 'kimpal',
'terkimpus': 'kimpus',
'kinangan': 'kinang',
'penginangan': 'kinang',
'mengincah': 'kincah',
'terkincak-kincak': 'kincak',
'mengincau': 'kincau',
'kinciran': 'kincir',
'berkincir': 'kincir',
'mengincup': 'kincup',
'terkindap-kindap': 'kindap',
'berkinerja': 'kinerja',
'berkinerjanya': 'kinerja',
'kekinian': 'kini',
'kekiniannya': 'kini',
'kekinianlah': 'kini',
'berkinja-kinja': 'kinja',
'terkinja-kinja': 'kinja',
'terkinjat': 'kinjat',
'perkintakaan': 'kintaka',
'berkinte': 'kinte',
'mengintil': 'kintil',
'mengintili': 'kintil',
'mengipaikan': 'kipai',
'kipasan': 'kipas',
'berkipas': 'kipas',
'mengipas': 'kipas',
'mengipasnya': 'kipas',
'mengipaskan': 'kipas',
'mengipasi': 'kipas',
'pengipas': 'kipas',
'mengipasinya': 'kipas',
'pengipasan': 'kipas',
'berkipas-kipas': 'kipas',
'mengipas-ngipas': 'kipas',
'mengipas-ngipaskan': 'kipas',
'mengipas-ngipasi': 'kipas',
'berkiprah': 'kiprah',
'berkiprahnya': 'kiprah',
'berkiprahlah': 'kiprah',
'mengipratkan': 'kiprat',
'mengekir': 'kir',
'mengekirkan': 'kir',
'kiraan': 'kira',
'kiraannya': 'kira',
'terkira': 'kira',
'terkirakan': 'kira',
'kiranya': 'kira',
'mengira': 'kira',
'mengiranya': 'kira',
'mengirakan': 'kira',
'mengiraku': 'kira',
'perkiraan': 'kira',
'perkiraannya': 'kira',
'perkiraankan': 'kira',
'perkiraanku': 'kira',
'perkiraanmu': 'kira',
'kira-kira': 'kira',
'kira-kiranya': 'kira',
'kira-kiralah': 'kira',
'pengiraan': 'kira',
'sekiranya': 'sekira',
'sekira-kira': 'kira',
'sekira-kiranya': 'kira',
'kira-kiraan': 'kira',
'berkira-kira': 'kira',
'mengira-ngira': 'kira',
'memperkirakan': 'kira',
'memperkirakannya': 'kira',
'mengira-ngirakan': 'kira',
'mengirabkan': 'kirab',
'berkirai': 'kirai',
'mengirai': 'kirai',
'mengiraikan': 'kirai',
'terkirai-kirai': 'kirai',
'mengirap': 'kirap',
'mengirapkan': 'kirap',
'memperkirapkan': 'kirap',
'berkirung': 'kirung',
'mengisa': 'kisa',
'mengisakan': 'kisa',
'mengisai': 'kisai',
'kisahan': 'kisah',
'terkisah': 'kisah',
'terkisahkan': 'kisah',
'berkisah': 'kisah',
'berkisahlah': 'kisah',
'berkisahkan': 'kisah',
'pengisahan': 'kisah',
'pengisahannya': 'kisah',
'mengisahkan': 'kisah',
'mengisahkannya': 'kisah',
'kisaian': 'kisai',
'mengisas': 'kisas',
'pengisat': 'kisat',
'pengisatan': 'kisat',
'mengisatkan': 'kisat',
'berkisi': 'kisi',
'kisi-kisi': 'kisi',
'kisi-kisinya': 'kisi',
'kisi-kisilah': 'kisi',
'kisikan': 'kisik',
'mengisik': 'kisik',
'kekisruhan': 'kisruh',
'kekisruhannya': 'kisruh',
'mengisruhkan': 'kisruh',
'pengisut': 'kisut',
'mengisut': 'kisut',
'mengisutkan': 'kisut',
'kekitaan': 'kita',
'berkitab': 'kitab',
'pengitaban': 'kitab',
'kitang-kitang': 'kitang',
'mengitik': 'kitik',
'mengitik-ngitik': 'kitik',
'kitiran': 'kitir',
'terkiuk': 'kiuk',
'pengklaim': 'klaim',
'pengklaiman': 'klaim',
'mengklaim': 'klaim',
'mengklaimnya': 'klaim',
'mengklaimlah': 'klaim',
'mengklaimkan': 'klaim',
'mengklaimi': 'klaim',
'pengklaimannya': 'klaim',
'mengklakson': 'klakson',
'mengklaksonnya': 'klakson',
'mengklaksonkan': 'klakson',
'mengklarifikasi': 'klarifikasi',
'mengklarifikasinya': 'klarifikasi',
'mengklarifikasikan': 'klarifikasi',
'mengklarifikasikannya': 'klarifikasi',
'mengklasifikasi': 'klasifikasi',
'mengklasifikasinya': 'klasifikasi',
'mengklasifikasikan': 'klasifikasi',
'mengklasifikasikannya': 'klasifikasi',
'pengklasifikasi': 'klasifikasi',
'pengklasifikasian': 'klasifikasi',
'pengklasifikasiannya': 'klasifikasi',
'klik-klikan': 'klik',
'mengeklirkan': 'klir',
'mengkliring': 'kliring',
'mengkliringkan': 'kliring',
'mengklise': 'klise',
'keklisean': 'klise',
'pengklonaan': 'klona',
'mengklonakan': 'klona',
'keklorinan': 'klorin',
'pengklorinan': 'klorin',
'koak-koak': 'koak',
'berkoak-koak': 'koak',
'berkoalisi': 'koalisi',
'berkoalisinya': 'koalisi',
'berkoalisilah': 'koalisi',
'berkoalisii': 'koalisi',
'berkoar': 'koar',
'berkoar-koar': 'koar',
'berkoar-koarnya': 'koar',
'kobakan': 'kobak',
'koboi-koboian': 'koboi',
'kekoboi-koboian': 'koboi',
'kobokan': 'kobok',
'berkobok': 'kobok',
'mengobok': 'kobok',
'berkobok-kobok': 'kobok',
'terkocoh-kocoh': 'kocoh',
'mengocok': 'kocok',
'mengocoknya': 'kocok',
'pengocok': 'kocok',
'pengocokkan': 'kocok',
'pengocokan': 'kocok',
'mengocong': 'kocong',
'mengocongkan': 'kocong',
'kocoran': 'kocor',
'mengocor': 'kocor',
'mengocorkan': 'kocor',
'mengodekan': 'kode',
'mengodekannya': 'kode',
'sekodi': 'kodi',
'kodian': 'kodi',
'berkodi-kodi': 'kodi',
'pengodifikasian': 'kodifikasi',
'mengodifikasikan': 'kodifikasi',
'mengodok': 'kodok',
'kekohesifan': 'kohesif',
'terkojol-kojol': 'kojol',
'mengokang': 'kokang',
'mengokangnya': 'kokang',
'mengokol': 'kokol',
'terkokol': 'kokol',
'terkokol-kokol': 'kokol',
'terkokot': 'kokot',
'mengokot': 'kokot',
'berkolaborasi': 'kolaborasi',
'berkolek-kolek': 'kolek',
'mengoleksi': 'koleksi',
'mengoleksinya': 'koleksi',
'kekolektifan': 'kolektif',
'kolokan': 'kolok',
'berkolokasi': 'kolokasi',
'kolongan': 'kolong',
'kolong-kolong': 'kolong',
'kekolotan': 'kolot',
'berkolusi': 'kolusi',
'koma-koma': 'koma',
'mengomando': 'komando',
'mengomandokan': 'komando',
'mengomandoi': 'komando',
'pengomandoan': 'komando',
'berkomat-kamit': 'komat-kamit',
'berkombinasi': 'kombinasi',
'mengombinasikan': 'kombinasi',
'mengombinasikannya': 'kombinasi',
'sekomeng': 'komeng',
'berkomentar': 'komentar',
'berkomentarlah': 'komentar',
'mengomentari': 'komentar',
'mengomentarinya': 'komentar',
'mengomersialkan': 'komersial',
'mengomersialkannya': 'komersial',
'mengomidikan': 'komidi',
'mengomisi': 'komisi',
'mengomisikan': 'komisi',
'mengomit': 'komit',
'berkompanyon': 'kompanyon',
'mengompas': 'kompas',
'kompenian': 'kompeni',
'mengompes': 'kompes',
'mengompori': 'kompor',
'mengomporinya': 'kompor',
'pengomporan': 'kompor',
'mengompos': 'kompos',
'mengomposkan': 'kompos',
'mengompres': 'kompres',
'mengompresnya': 'kompres',
'mengompresi': 'kompres',
'mengomputerkan': 'komputer',
'berkomunikasi': 'komunikasi',
'berkomunikasinya': 'komunikasi',
'berkomunikasilah': 'komunikasi',
'berkomunikasikan': 'komunikasi',
'mengomunikasikan': 'komunikasi',
'mengomunikasikannya': 'komunikasi',
'mengomuniskan': 'komunis',
'mengonan': 'konan',
'mengonani': 'konan',
'perkoncoan': 'konco',
'mengonde': 'konde',
'mengondensasikan': 'kondensasi',
'mengondisikan': 'kondisi',
'mengondisikannya': 'kondisi',
'mengonferensikan': 'konferensi',
'mengonfirmasikan': 'konfirmasi',
'mengonfirmasikannya': 'konfirmasi',
'berkongkalikong': 'kongkalikong',
'kongko-kongko': 'kongko',
'kongkongan': 'kongkong',
'mengongkong': 'kongkong',
'terkongkong': 'kongkong',
'memperkonon': 'konon',
'mengononkan': 'konon',
'mengonsentrasikan': 'konsentrasi',
'mengonsep': 'konsep',
'mengonsepkan': 'konsep',
'pengonsep': 'konsep',
'pengonsepan': 'konsep',
'mengonsolidasikan': 'konsolidasi',
'mengonsolidasikannya': 'konsolidasi',
'mengonstatir': 'konstatir',
'berkonsultasi': 'konsultasi',
'berkonsultasilah': 'konsultasi',
'berkonsultasikan': 'konsultasi',
'mengonsumsi': 'konsumsi',
'mengonsumsinya': 'konsumsi',
'mengonsumsikan': 'konsumsi',
'pengonsumsian': 'konsumsi',
'pengonsumsiannya': 'konsumsi',
'berkontak': 'kontak',
'mengontak': 'kontak',
'mengontaknya': 'kontak',
'mengontakku': 'kontak',
'terkontaminasi': 'kontaminasi',
'terkontaminasinya': 'kontaminasi',
'mengontaminasi': 'kontaminasi',
'mengontaminasinya': 'kontaminasi',
'mengontaminasikan': 'kontaminasi',
'mengontan': 'kontan',
'berkontemplasi': 'kontemplasi',
'mengonter': 'konter',
'kontrakan': 'kontrak',
'kontrakannya': 'kontrak',
'kontrakanku': 'kontrak',
'mengontrak': 'kontrak',
'mengontraknya': 'kontrak',
'mengontrakkan': 'kontrak',
'mengontrakkannya': 'kontrak',
'mengontrakan': 'kontrak',
'mengontrakku': 'kontrak',
'pengontrak': 'kontrak',
'pengontraknya': 'kontrak',
'pengontrakan': 'kontrak',
'berkontraksi': 'kontraksi',
'berkontraksinya': 'kontraksi',
'kekontrasan': 'kontras',
'kekontrasannya': 'kontras',
'pengontrasan': 'kontras',
'mengontraskan': 'kontras',
'mengontrol': 'kontrol',
'mengontrolnya': 'kontrol',
'mengontrolkan': 'kontrol',
'mengontrolan': 'kontrol',
'pengontrol': 'kontrol',
'pengontrolnya': 'kontrol',
'pengontrolan': 'kontrol',
'terkontrol': 'kontrol',
'terkontrolnya': 'kontrol',
'terkontrollah': 'kontrol',
'pengontrolannya': 'kontrol',
'mengonvergensikan': 'konvergensi',
'mengonversikan': 'konversi',
'mengonversikannya': 'konversi',
'kekonyolan': 'konyol',
'kekonyolannya': 'konyol',
'berkooperasi': 'kooperasi',
'terkooptasi': 'kooptasi',
'terkooptasinya': 'kooptasi',
'mengooptasi': 'kooptasi',
'pengooptasian': 'kooptasi',
'mengoordinasi': 'koordinasi',
'mengoordinasinya': 'koordinasi',
'mengoordinasikan': 'koordinasi',
'mengoordinasikannya': 'koordinasi',
'terkoordinasi': 'koordinasi',
'terkoordinasinya': 'koordinasi',
'terkoordinasikan': 'koordinasi',
'terkoordinasikannya': 'koordinasi',
'berkoordinasi': 'koordinasi',
'berkoordinasilah': 'koordinasi',
'berkoordinasikan': 'koordinasi',
'pengoordinasian': 'koordinasi',
'berkop': 'kop',
'mengekop': 'kop',
'berkopah-kopah': 'kopah',
'mengopak': 'opak',
'mengopek': 'kopek',
'berkoper-koper': 'koper',
'berkoperasi': 'koperasi',
'perkoperasian': 'koperasi',
'perkoperasiannya': 'koperasi',
'mengopi': 'kopi',
'mengopinya': 'kopi',
'pengopi': 'kopi',
'pengopian': 'kopi',
'perkopian': 'kopi',
'kopokan': 'kopok',
'perkopraan': 'kopra',
'koprakan': 'koprak',
'mengopyok': 'kopyok',
'berkoran': 'koran',
'mengorankan': 'koran',
'berkorban': 'korban',
'berkorbannya': 'korban',
'berkorbanlah': 'korban',
'berkorbanan': 'korban',
'pengorbanan': 'korban',
'pengorbanannya': 'korban',
'pengorbananlah': 'korban',
'pengorbananan': 'korban',
'pengorbananku': 'korban',
'pengorbananmu': 'korban',
'mengorbankan': 'korban',
'mengorbankannya': 'korban',
'mengorbankanku': 'korban',
'mengored': 'kored',
'korekan': 'korek',
'mengorek': 'korek',
'mengoreknya': 'korek',
'pengorek': 'korek',
'pengorekan': 'korek',
'mengorek-ngorek': 'korek',
'mengorek-ngoreknya': 'korek',
'koreksian': 'koreksi',
'koreksiannya': 'koreksi',
'mengoreksi': 'koreksi',
'mengoreksinya': 'koreksi',
'mengoreksimu': 'koreksi',
'pengoreksi': 'koreksi',
'pengoreksian': 'koreksi',
'berkorelasi': 'korelasi',
'mengorelasikan': 'korelasi',
'korengan': 'koreng',
'berkoreng': 'koreng',
'koreng-koreng': 'koreng',
'berkorespondensi': 'korespondensi',
'koretan': 'koret',
'mengorok': 'orok',
'berkorong': 'korong',
'mengorting': 'korting',
'mengorup': 'korup',
'mengorupsi': 'korupsi',
'mengosek': 'kosek',
'terkosel-kosel': 'kosel',
'kekosenan': 'kosen',
'kekosongan': 'kosong',
'kekosongannya': 'kosong',
'pengosongan': 'kosong',
'pengosongannya': 'kosong',
'mengosongkan': 'kosong',
'mengosongkannya': 'kosong',
'sekosong-kosongnya': 'kosong',
'berkostum': 'kostum',
'berkostumkan': 'kostum',
'berkota': 'kota',
'mengota': 'kota',
'mengotakan': 'kotak',
'mengotai': 'kota',
'kekotaan': 'kota',
'perkotaan': 'kota',
'perkotaannya': 'kota',
'pengotaan': 'kota',
'kekota-kotaan': 'kota',
'sekotah': 'kotah',
'mengotak-ngatikkan': 'kotak katik',
'terkotak': 'kotak',
'terkotakan': 'kotak',
'mengotak': 'kotak',
'mengotakkan': 'kotak',
'mengotaki': 'otak',
'pengotakan': 'kotak',
'berkotak-kotak': 'kotak',
'berkotak-kotakkan': 'kotak',
'berkotak-kotakan': 'kotak',
'terkotak-kotak': 'kotak',
'terkotak-kotaknya': 'kotak',
'terkotak-kotakkan': 'kotak',
'terkotak-kotakan': 'kotak',
'pengotak-ngotakan': 'kotak',
'mengotak-ngotakkan': 'kotak',
'terkoteng-koteng': 'koteng',
'sekotes': 'kotes',
'mengotes': 'kotes',
'kotoran': 'kotor',
'kotorannya': 'kotor',
'pengotor': 'kotor',
'pengotornya': 'kotor',
'pengotoran': 'kotor',
'mengotori': 'kotor',
'mengotorinya': 'kotor',
'kekotoran': 'kotor',
'kekotorannya': 'kotor',
'mengotorkan': 'kotor',
'mengover': 'kover',
'kowekan': 'kowek',
'mengoyak': 'oyak',
'mengoyaknya': 'oyak',
'mengoyakkan': 'oyak',
'mengoyaki': 'oyak',
'mengoyakan': 'oyak',
'koyak-koyak': 'koyak',
'mengoyak-ngoyak': 'koyak',
'mengoyak-ngoyaknya': 'koyak',
'mengoyak-ngoyakkan': 'koyak',
'berkreasi': 'kreasi',
'berkreasinya': 'kreasi',
'berkreasilah': 'kreasi',
'kekreatifan': 'kreatif',
'kekreatifannya': 'kreatif',
'kreditan': 'kredit',
'kreditannya': 'kredit',
'mengkredit': 'kredit',
'mengkreditnya': 'kredit',
'mengkreditkan': 'kredit',
'pengkredit': 'kredit',
'pengkreditan': 'kredit',
'perkreditan': 'kredit',
'mengkrisis': 'krisis',
'mengkristal': 'kristal',
'mengkristalnya': 'kristal',
'mengkristalkan': 'kristal',
'pengkristalan': 'kristal',
'kekristenan': 'kristen',
'kekristenannya': 'kristen',
'mengkristenkan': 'kristen',
'pengkritik': 'kritik',
'pengkritiknya': 'kritik',
'mengkritik': 'kritik',
'mengkritiknya': 'kritik',
'mengkritiklah': 'kritik',
'mengkritiki': 'kritik',
'mengkritikan': 'kritik',
'mengkritikku': 'kritik',
'mengkritikmu': 'kritik',
'mengkritis': 'kritis',
'mengkritisnya': 'kritis',
'mengkritisi': 'kritis',
'kekritisan': 'kritis',
'kekritisannya': 'kritis',
'berkuah': 'kuah',
'berkuahkan': 'kuah',
'menguahi': 'kuah',
'menguahkan': 'kuah',
'terkuai-kuai': 'kuai',
'terkuak': 'kuak',
'terkuaknya': 'kuak',
'terkuaklah': 'kuak',
'menguak': 'uak',
'menguaknya': 'uak',
'menguakkan': 'uak',
'menguakan': 'uak',
'berkuala': 'kuala',
'berkualifikasi': 'kualifikasi',
'mengualifikasikan': 'kualifikasi',
'berkualitas': 'kualitas',
'berkualitasnya': 'kualitas',
'berkualitaslah': 'kualitas',
'berkualitasi': 'kualitas',
'menguap': 'uap',
'menguapnya': 'uap',
'menguaplah': 'uap',
'menguapkan': 'uap',
'menguapkannya': 'uap',
'menguapi': 'uap',
'kuaran': 'kuar',
'menguarkan': 'uar',
'menguar-nguarkan': 'kuar',
'kuas-kuas': 'kuas',
'berkubak': 'kubak',
'mengubak': 'kubak',
'terkubak': 'kubak',
'mengubik': 'kubik',
'sekubit': 'kubit',
'mengubit': 'kubit',
'mengubrakan': 'kubra',
'kuburan': 'kubur',
'kuburannya': 'kubur',
'kuburanlah': 'kubur',
'kuburanku': 'kubur',
'kuburanmu': 'kubur',
'terkubur': 'kubur',
'terkuburnya': 'kubur',
'terkuburlah': 'kubur',
'mengubur': 'kubur',
'menguburnya': 'kubur',
'menguburkan': 'kubur',
'menguburkannya': 'kubur',
'menguburi': 'kubur',
'menguburku': 'kubur',
'menguburmu': 'kubur',
'berkubur': 'kubur',
'pekuburan': 'kubur',
'penguburan': 'kubur',
'penguburannya': 'kubur',
'penguburanku': 'kubur',
'menguburkanmu': 'kubur',
'terkucai': 'kucai',
'mengucai': 'kucai',
'berkucak': 'kucak',
'mengucak': 'kucak',
'mengucakan': 'kucak',
'terkucak': 'kucak',
'mengucar-ngacirkan': 'kucar-kacir',
'mengucek-ngucek': 'kucek',
'terkucil': 'kucil',
'terkucilnya': 'kucil',
'terkucilkan': 'kucil',
'mengucil': 'kucil',
'mengucilkan': 'kucil',
'mengucilkannya': 'kucil',
'kucing-kucing': 'kucing',
'kucing-kucingnya': 'kucing',
'kucing-kucingan': 'kucing',
'kucing-kucingku': 'kucing',
'kucing-kucingannya': 'kucing',
'kucing-kucinganlah': 'kucing',
'mengucup': 'kucup',
'mengucupkan': 'kucup',
'kucuran': 'kucur',
'kucurannya': 'kucur',
'mengucur': 'kucur',
'mengucurnya': 'kucur',
'mengucurlah': 'kucur',
'mengucurkan': 'kucur',
'mengucurkannya': 'kucur',
'mengucuri': 'kucur',
'berkucur': 'kucur',
'berkucuran': 'kucur',
'kudangan': 'kudang',
'kudapan': 'kudap',
'kudapannya': 'kudap',
'mengudap': 'kudap',
'mengudapnya': 'kudap',
'pengudap': 'kudap',
'kudap-kudap': 'kudap',
'mengudeta': 'kudeta',
'mengudian': 'kudian',
'terkudian': 'kudian',
'mengudiankan': 'kudian',
'kudisan': 'kudis',
'berkudis': 'kudis',
'sekudung': 'kudung',
'berkudung': 'kudung',
'pengudung': 'kudung',
'mengudung': 'kudung',
'pengudungan': 'kudung',
'mengudungkan': 'kudung',
'kekudusan': 'kudus',
'kekudusannya': 'kudus',
'pengudusan': 'kudus',
'menguduskan': 'kudus',
'kue-kue': 'kue',
'kue-kuenya': 'kue',
'sekufu': 'kufu',
'kekufuran': 'kufur',
'kekufurannya': 'kufur',
'mengufurkan': 'kufur',
'menguis': 'kuis',
'menguit': 'uit',
'sekujur': 'kujur',
'sekujurnya': 'kujur',
'pengujut': 'kujut',
'terkujut': 'kujut',
'mengujut': 'kujut',
'mengujutkan': 'kujut',
'berkujut': 'kujut',
'kukuran': 'kukur',
'kukusan': 'kukus',
'mengukus': 'kukus',
'mengukusnya': 'kukus',
'berkukus': 'kukus',
'kulah-kulah': 'kulah',
'terkulai': 'kulai',
'terkulainya': 'kulai',
'berkulai': 'kulai',
'berkulaian': 'kulai',
'perkulakan': 'kulak',
'kulak-kulak tangan': 'kulak',
'berkulimat': 'kulimat',
'mengulit': 'ulit',
'menguliti': 'ulit',
'pengulit': 'kulit',
'pengulitan': 'kulit',
'berkulit': 'kulit',
'mengulitinya': 'kulit',
'perkulitan': 'kulit',
'pengultusan': 'kultus',
'pengultusannya': 'kultus',
'mengultuskan': 'kultus',
'mengulub': 'kulub',
'mengulum': 'kulum',
'mengulumnya': 'kulum',
'kulum-kulum': 'kulum',
'mengulum-ngulum': 'kulum',
'berkulup': 'kulup',
'kumaian': 'kumai',
'berkumai': 'kumai',
'mengumai': 'kumai',
'mengumaikan': 'kumai',
'mengumalkan': 'kumal',
'mengumandang': 'kumandang',
'mengumandangkan': 'kumandang',
'mengumandangkannya': 'kumandang',
'berkumandang': 'kumandang',
'berkumandangnya': 'kumandang',
'berkumandangkan': 'kumandang',
'kumat-kamit': 'kumat',
'mengumbah': 'kumbah',
'mengumbang': 'umbang',
'mengumbangkan': 'umbang',
'mengumbangi': 'umbang',
'berkumis': 'kumis',
'berkumisan': 'kumis',
'berkumpai': 'kumpai',
'terkumpal-kumpal': 'kumpal',
'kumparan': 'kumpar',
'kumparannya': 'kumpar',
'mengumpar': 'kumpar',
'kekumuhan': 'kumuh',
'kekumuhannya': 'kumuh',
'mengumuhkan': 'kumuh',
'berkumut': 'kumut',
'berkunang-kunang': 'kunang-kunang',
'berkunar-kunar': 'kunar-kunar',
'mengunci': 'kunci',
'menguncinya': 'kunci',
'menguncikan': 'kunci',
'terkunci': 'kunci',
'terkuncinya': 'kunci',
'pengunci': 'kunci',
'penguncinya': 'kunci',
'penguncian': 'kunci',
'menguncup': 'kuncup',
'penguncupan': 'kuncup',
'menguncupkan': 'kuncup',
'mengundai': 'kundai',
'kundangan': 'kundang',
'mengundang': 'undang',
'mengundangnya': 'undang',
'mengundangkan': 'undang',
'mengundangkannya': 'undang',
'mengundangan': 'undang',
'mengundangku': 'undang',
'mengundangmu': 'undang',
'berkundang': 'kundang',
'mengungkang': 'kungkang',
'kungkungan': 'kungkung',
'kungkungannya': 'kungkung',
'terkungkung': 'kungkung',
'mengungkung': 'kungkung',
'mengungkungnya': 'kungkung',
'menguntit': 'kuntit',
'menguntitnya': 'kuntit',
'menguntiti': 'kuntit',
'terkuntum': 'kuntum',
'menguntum': 'kuntum',
'kunyahan': 'kunyah',
'kunyahannya': 'kunyah',
'mengunyah': 'kunyah',
'mengunyahnya': 'kunyah',
'mengunyahlah': 'kunyah',
'mengunyahkan': 'kunyah',
'mengunyahkannya': 'kunyah',
'terkunyah': 'kunyah',
'kupakan': 'kupak',
'berkupak': 'kupak',
'mengupak': 'upak',
'mengupakan': 'upak',
'kupasan': 'kupas',
'kupasannya': 'kupas',
'terkupas': 'kupas',
'mengupas': 'kupas',
'mengupasnya': 'kupas',
'mengupaskan': 'kupas',
'pengupas': 'kupas',
'pengupasan': 'kupas',
'pengupasannya': 'kupas',
'mengupil': 'upil',
'menguping': 'kuping',
'berkuping': 'kuping',
'mengupingi': 'kuping',
'berkurai': 'kurai',
'berkurap': 'kurap',
'terkuras': 'kuras',
'terkurasnya': 'kuras',
'terkurasi': 'kuras',
'menguras': 'uras',
'mengurasnya': 'uras',
'mengurasi': 'uras',
'pengurasan': 'kuras',
'pengurasannya': 'kuras',
'kekuratoran': 'kurator',
'berkurban': 'kurban',
'berkurbannya': 'kurban',
'mengurbankan': 'kurban',
'mengurbankannya': 'kurban',
'menguret': 'kuret',
'penguretan': 'kuret',
'kuricakan': 'kuricak',
'berkurik-kurik': 'kurik',
'mengursus': 'kursus',
'mengursuskan': 'kursus',
'berkurun-kurun': 'kurun',
'kurungan': 'kurung',
'kurungannya': 'kurung',
'mengurung': 'kurung',
'mengurungnya': 'kurung',
'mengurungkan': 'urung',
'mengurungkannya': 'urung',
'mengurungi': 'kurung',
'mengurungmu': 'kurung',
'terkurung': 'kurung',
'terkurungnya': 'kurung',
'berkurung': 'kurung',
'pengurungan': 'kurung',
'pengurungannya': 'kurung',
'mengusa': 'kusa',
'mengusakannya': 'kusa',
'mengusai': 'usai',
'mengusal': 'kusal',
'mengusalkan': 'kusal',
'berkusau-kusau': 'kusau',
'berkusik': 'kusik',
'mengusruk': 'kusruk',
'mengusrukkan': 'kusruk',
'berkusu-kusu': 'kusu',
'mengusuk': 'kusuk',
'mengusukkan': 'kusuk',
'mengusukan': 'kusuk',
'berkusuk': 'kusuk',
'berkuta': 'kuta',
'mengutak-ngatikkan': 'kutak',
'berkutat': 'kutat',
'berkutatnya': 'kutat',
'berkuteks': 'kuteks',
'menguti': 'kuti',
'kuti-kuti': 'kuti',
'kutikan': 'kutik',
'mengutik': 'kutik',
'berkutik': 'kutik',
'berkutiknya': 'kutik',
'mengutik-ngutik': 'kutik',
'sekutil': 'kutil',
'mengutil': 'kutil',
'pengutil': 'kutil',
'pengutilan': 'kutil',
'berkuting-kuting': 'kuting',
'kutipan': 'kutip',
'kutipannya': 'kutip',
'mengutip': 'kutip',
'mengutipnya': 'kutip',
'mengutipkan': 'kutip',
'pengutip': 'kutip',
'pengutipan': 'kutip',
'berkutu': 'kutu',
'berkutuan': 'kutu',
'mengutui': 'kutu',
'berkutu-kutuan': 'kutu',
'berkutub': 'kutub',
'kutukan': 'kutuk',
'kutukannya': 'kutuk',
'sekutuk': 'kutuk',
'terkutuk': 'kutuk',
'terkutuknya': 'kutuk',
'terkutuklah': 'kutuk',
'mengutuk': 'kutuk',
'mengutuknya': 'kutuk',
'mengutuki': 'kutuk',
'mengutukan': 'kutuk',
'mengutukku': 'kutuk',
'mengutukmu': 'kutuk',
'mengutukinya': 'kutuk',
'keterkutukan': 'kutuk',
'keterkutukannya': 'kutuk',
'sekutuk tipe unggul': 'kutuk',
'menguyup': 'kuyup',
'menguyupkan': 'kuyup',
'berlaba': 'laba',
'melabai': 'laba',
'melabaikan': 'laba',
'melabakan': 'laba',
'melabang': 'labang',
'berlabel': 'label',
'berlabelkan': 'label',
'pelabelan': 'label',
'pelabelannya': 'label',
'melabelkan': 'label',
'melabelkannya': 'label',
'labilitas': 'labi-labi',
'kelabilan': 'labil',
'melabrak': 'labrak',
'melabraknya': 'labrak',
'melabrakku': 'labrak',
'melabu': 'labu',
'melabukan': 'labu',
'melabui': 'labu',
'labu-labu': 'labu',
'labu-labuan': 'labu',
'berlabun-labun': 'labun',
'melabur': 'labur',
'melaburnya': 'labur',
'pelabur': 'labur',
'pelaburan': 'labur',
'kelaburan': 'labur',
'melacak': 'lacak',
'melacaknya': 'lacak',
'melacakan': 'lacak',
'pelacak': 'lacak',
'pelacaknya': 'lacak',
'pelacakkan': 'lacak',
'pelacakan': 'lacak',
'belacak': 'lacak',
'terlacak': 'lacak',
'terlacaknya': 'lacak',
'terlacaklah': 'lacak',
'pelacakannya': 'lacak',
'melacur': 'lacur',
'melacurkan': 'lacur',
'melacurkannya': 'lacur',
'pelacur': 'lacur',
'pelacurnya': 'lacur',
'pelacuran': 'lacur',
'pelacurmu': 'lacur',
'pelacurannya': 'lacur',
'melacut': 'lacut',
'meladai': 'lada',
'peladen': 'laden',
'ladenan': 'laden',
'meladeni': 'laden',
'meladeninya': 'laden',
'peladenan': 'laden',
'berladung': 'ladung',
'meladungkan': 'ladung',
'melafalkan': 'lafal',
'melafalkannya': 'lafal',
'pelagak': 'lagak',
'melagak': 'lagak',
'berlagak': 'lagak',
'melagakkan': 'lagak',
'melagang': 'lagang',
'melagangkan': 'lagang',
'lagian': 'lagi',
'selagi': 'lagi',
'lagi-lagi': 'lagi',
'laguan': 'lagu',
'pelagu': 'lagu',
'belagu': 'lagu',
'belagunya': 'lagu',
'belagulah': 'lagu',
'melagu': 'lagu',
'melagukan': 'lagu',
'melagukannya': 'lagu',
'berlagu': 'lagu',
'melagui': 'lagu',
'pelahap': 'lahap',
'melahap': 'lahap',
'melahapnya': 'lahap',
'berlahar': 'lahar',
'terlahir': 'lahir',
'terlahirnya': 'lahir',
'terlahirlah': 'lahir',
'terlahirkan': 'lahir',
'kelahiran': 'lahir',
'kelahirannya': 'lahir',
'kelahiranku': 'lahir',
'kelahiranmu': 'lahir',
'melahirkan': 'lahir',
'melahirkannya': 'lahir',
'melahirkankan': 'lahir',
'melahirkanku': 'lahir',
'melahirkanmu': 'lahir',
'kelaikan': 'laik',
'kelaikannya': 'laik',
'melais': 'lais',
'melajang': 'lajang',
'melaju': 'laju',
'melajunya': 'laju',
'melajulah': 'laju',
'melajukan': 'laju',
'melajukannya': 'laju',
'kelajuan': 'laju',
'perlajuan': 'laju',
'bersilaju': 'laju',
'berlaju-laju': 'laju',
'berlajur': 'lajur',
'melakabkan': 'lakab',
'melakak': 'lakak',
'melakakan': 'lakak',
'berlaki': 'laki',
'laki-laki': 'laki',
'laki-lakinya': 'laki',
'laki-lakilah': 'laki',
'laki-lakinyalah': 'laki',
'laki-lakiku': 'laki',
'laki-lakimu': 'laki',
'memperlaki': 'laki',
'kelaki-lakian': 'laki',
'kelaki-lakiannya': 'laki',
'memperlakikan': 'laki',
'melaknat': 'laknat',
'melaknatnya': 'laknat',
'melaknati': 'laknat',
'melaknatkan': 'laknat',
'lelakon': 'lakon',
'pelakon': 'lakon',
'pelakonnya': 'lakon',
'melakoni': 'lakon',
'melakoninya': 'lakon',
'melakonii': 'lakon',
'berlakon': 'lakon',
'melakonkan': 'lakon',
'melakonkannya': 'lakon',
'pelaksana': 'laksana',
'pelaksananya': 'laksana',
'pelaksanakan': 'laksana',
'pelaksanakannya': 'laksana',
'pelaksanaan': 'laksana',
'terlaksana': 'laksana',
'terlaksananya': 'laksana',
'terlaksanalah': 'laksana',
'terlaksanakan': 'laksana',
'pelaksanaannya': 'laksana',
'pelaksanaanan': 'laksana',
'melaksanakan': 'laksana',
'melaksanakannya': 'laksana',
'melaksanakanan': 'laksana',
'berlaku lajak': 'laku lajak',
'melakurkan': 'lakur',
'melala': 'lala',
'melalai': 'lala',
'pelalah': 'lalah',
'pelalahan': 'lalah',
'melalah': 'lalah',
'terlalah': 'lalah',
'melalak': 'lalak',
'melalap': 'lalap',
'melalapnya': 'lalap',
'melalapkan': 'lalap',
'melalau': 'lalau',
'melalaui': 'lalau',
'pelalau': 'lalau',
'pelalauan': 'lalau',
'melali': 'lali',
'melalikan': 'lali',
'melalii': 'lali',
'berlalu lintas': 'lalu lintas',
'perlalulintasan': 'lalu lintas',
'selama': 'lama',
'selamanya': 'lama',
'selamai': 'lama',
'kelamaan': 'lama',
'lama-lama': 'lama',
'lama-lamalah': 'lama',
'lama-lamaan': 'lama',
'memperlama': 'lama',
'berlama-lama': 'lama',
'berlama-lamanya': 'lama',
'berlama-lamalah': 'lama',
'berlama-lamaan': 'lama',
'lama-kelamaan': 'lama',
'memperlamakan': 'lama',
'selama-lamanya': 'lama',
'selama-lamanyanya': 'lama',
'pelamar': 'lamar',
'pelamarnya': 'lamar',
'pelamaran': 'lamar',
'melamar': 'lamar',
'melamarnya': 'lamar',
'melamarkan': 'lamar',
'melamarku': 'lamar',
'melamarmu': 'lamar',
'lamaran': 'lamar',
'lamarannya': 'lamar',
'lamaranku': 'lamar',
'lamaranmu': 'lamar',
'lambaian': 'lambai',
'melambai': 'lambai',
'melambailah': 'lambai',
'melambaikan': 'lambai',
'melambaikannya': 'lambai',
'melambai-lambai': 'lambai',
'melambai-lambaikan': 'lambai',
'melambai-lambaikannya': 'lambai',
'berlambai-lambai': 'lambai',
'kelambanan': 'lamban',
'kelambanannya': 'lamban',
'kelambananan': 'lamban',
'melambankan': 'lamban',
'berlambang': 'lambang',
'berlambangkan': 'lambang',
'berlambangan': 'lambang',
'pelambangan': 'lambang',
'melambangkan': 'lambang',
'melambangkannya': 'lambang',
'melambari': 'lambar',
'terlambat': 'lambat',
'terlambatnya': 'lambat',
'terlambatan': 'lambat',
'berlambat': 'lambat',
'kelambatan': 'lambat',
'kelambatannya': 'lambat',
'melambatkan': 'lambat',
'melambatkannya': 'lambat',
'memperlambat': 'lambat',
'memperlambatnya': 'lambat',
'memperlambatkan': 'lambat',
'lambat-lambat': 'lambat',
'lambat-lambatkan': 'lambat',
'keterlambatan': 'lambat',
'keterlambatannya': 'lambat',
'keterlambatanku': 'lambat',
'melambat-lambatkan': 'lambat',
'pelambuk': 'lambuk',
'melambuk': 'lambuk',
'melambung': 'lambung',
'melambungnya': 'lambung',
'melambungkan': 'lambung',
'melambungkannya': 'lambung',
'melambungan': 'lambung',
'melambungi': 'lambung',
'pelamin': 'lamin',
'pelaminan': 'lamin',
'melamin': 'lamin',
'pelaminannya': 'lamin',
'melampai': 'lampai',
'melampaikan': 'lampai',
'terlampai': 'lampai',
'melampam': 'lampam',
'melampan': 'lampan',
'melampang': 'lampang',
'melampangkan': 'lampang',
'berlampang': 'lampang',
'berlampang-lampang': 'lampang',
'berlampar': 'lampar',
'berlamparan': 'lampar',
'melampas': 'lampas',
'melampau': 'lampau',
'melampaui': 'lampau',
'melampauinya': 'lampau',
'melampauiku': 'lampau',
'melampauimu': 'lampau',
'terlampau': 'lampau',
'terlampaunya': 'lampau',
'terlampaui': 'lampau',
'terlampauinya': 'lampau',
'kelampauan': 'lampau',
'pelampiasan': 'lampias',
'pelampiasannya': 'lampias',
'melampiaskan': 'lampias',
'melampiaskannya': 'lampias',
'melampini': 'lampin',
'lampiran': 'lampir',
'lampirannya': 'lampir',
'terlampir': 'lampir',
'terlampirnya': 'lampir',
'melampiri': 'lampir',
'melampirinya': 'lampir',
'melampirkan': 'lampir',
'melampirkannya': 'lampir',
'berlampu': 'lampu',
'berlampukan': 'lampu',
'perlampuan': 'lampu',
'pelampung': 'lampung',
'pelampungnya': 'lampung',
'pelampungku': 'lampung',
'melampung': 'lampung',
'melamun': 'lamun',
'melamunkan': 'lamun',
'lamunan': 'lamun',
'lamunannya': 'lamun',
'lamunanku': 'lamun',
'dilamun': 'lamun',
'melanang': 'lanang',
'terlancap': 'lancap',
'lancingan': 'lancing',
'berlancing': 'lancing',
'melancip': 'lancip',
'melancipkan': 'lancip',
'melancong': 'lancong',
'melancongnya': 'lancong',
'melancongi': 'lancong',
'pelancong': 'lancong',
'pelancongnya': 'lancong',
'pelancongan': 'lancong',
'perpelancongan': 'lancong',
'lancungan': 'lancung',
'melancung': 'lancung',
'kelancungan': 'lancung',
'melancungkan': 'lancung',
'melancur': 'lancur',
'melancut': 'lancut',
'pelanda': 'landa',
'pelandakan': 'landa',
'melanda': 'landa',
'melandanya': 'landa',
'melandai': 'landai',
'melandaku': 'landa',
'melandamu': 'landa',
'terlanda': 'landa',
'terlandai': 'landa',
'melandakan': 'landa',
'landaian': 'landai',
'melandainya': 'landai',
'melandaikan': 'landai',
'landasan': 'landas',
'landasannya': 'landas',
'landasanan': 'landas',
'melandas': 'landas',
'melandaskan': 'landas',
'melandaskannya': 'landas',
'melandasi': 'landas',
'melandasinya': 'landas',
'berlandasan': 'landas',
'berlandaskan': 'landas',
'melandau': 'landau',
'melandung': 'landung',
'melangah': 'langah',
'terlangah': 'langah',
'melangahkan': 'langah',
'berlangau': 'langau',
'langganan': 'langgan',
'langganannya': 'langgan',
'langgananan': 'langgan',
'pelanggan': 'langgan',
'pelanggannya': 'langgan',
'pelangganlah': 'langgan',
'pelangganan': 'langgan',
'pelangganku': 'langgan',
'pelangganmu': 'langgan',
'melanggani': 'langgan',
'berlanggan': 'langgan',
'berlanggannya': 'langgan',
'berlangganan': 'langgan',
'berlangganannya': 'langgan',
'berlanggananan': 'langgan',
'pelanggar': 'langgar',
'pelanggarnya': 'langgar',
'pelanggaran': 'langgar',
'melanggar': 'langgar',
'melanggarnya': 'langgar',
'melanggarlah': 'langgar',
'melanggarkan': 'langgar',
'melanggaran': 'langgar',
'terlanggar': 'langgar',
'terlanggarnya': 'langgar',
'terlanggarkan': 'langgar',
'pelanggarannya': 'langgar',
'pelanggaranmu': 'langgar',
'berlanggaran': 'langgar',
'perlanggaran': 'langgar',
'langgar-melanggar': 'langgar',
'berlanggar-langgar': 'langgar',
'kelanggengan': 'langgeng',
'kelanggengannya': 'langgeng',
'melanggungkan': 'langgung',
'melangir': 'langir',
'berlangir': 'langir',
'selangit': 'langit',
'selangitnya': 'langit',
'melangit': 'langit',
'melangitnya': 'langit',
'melangitkan': 'langit',
'kelangkaan': 'langka',
'kelangkaannya': 'langka',
'melangkah': 'langkah',
'melangkahnya': 'langkah',
'melangkahlah': 'langkah',
'melangkahkan': 'langkah',
'melangkahi': 'langkah',
'selangkah': 'langkah',
'pelangkah': 'langkah',
'pelangkahi': 'langkah',
'pelangkahan': 'langkah',
'berlangkah': 'langkah',
'berlangkahlah': 'langkah',
'melangkahinya': 'langkah',
'kelangkahan': 'langkah',
'perlangkahan': 'langkah',
'terlangkahkan': 'langkah',
'memperlangkangkan': 'langkang',
'melangkapkan': 'langkap',
'selangkas': 'langkas',
'melangkaui': 'langkau',
'terlangkaui': 'langkau',
'langkupan': 'langkup',
'terlangkup': 'langkup',
'melanglang': 'langlang',
'berlanglang': 'langlang',
'melangsamkan': 'langsam',
'melangsar': 'langsar',
'melangsi': 'langsi',
'berlangsi': 'langsi',
'pelangsing': 'langsing',
'pelangsingnya': 'langsing',
'pelangsingan': 'langsing',
'kelangsingan': 'langsing',
'kelangsingannya': 'langsing',
'melangsingkan': 'langsing',
'melangsingkannya': 'langsing',
'melangsir': 'langsir',
'melangsirnya': 'langsir',
'melangsirkan': 'langsir',
'berlangsung': 'langsung',
'berlangsungnya': 'langsung',
'berlangsunglah': 'langsung',
'berlangsungkan': 'langsung',
'berlangsungi': 'langsung',
'berlangsungan': 'langsung',
'terlangsung': 'langsung',
'terlangsungnya': 'langsung',
'kelangsungan': 'langsung',
'kelangsungannya': 'langsung',
'melangsungkan': 'langsung',
'melangsungkannya': 'langsung',
'perlangsungan': 'langsung',
'keberlangsungan': 'langsung',
'keberlangsungannya': 'langsung',
'melangut': 'langut',
'melanja': 'lanja',
'lanja-lanjaan': 'lanja',
'melanjai': 'lanjai',
'lanjaran': 'lanjar',
'melanjar': 'lanjar',
'terlanjau': 'lanjau',
'telanjuk': 'lanjuk',
'melansir': 'lansir',
'melansirnya': 'lansir',
'melansirkan': 'lansir',
'melansiri': 'lansir',
'melantah': 'lantah',
'melantai': 'lantai',
'melantainya': 'lantai',
'melantaikan': 'lantai',
'berlantai': 'lantai',
'berlantaikan': 'lantai',
'pelantak': 'lantak',
'melantak': 'lantak',
'melantakkan': 'lantak',
'lantakan': 'lantak',
'kelantaman': 'lantam',
'melantamkan': 'lantam',
'melantan': 'lantan',
'terlantan': 'lantan',
'melantang': 'lantang',
'melantangkan': 'lantang',
'kelantangan': 'lantang',
'lantaran': 'lantar',
'lantarannya': 'lantar',
'lantaranan': 'lantar',
'pelantar': 'lantar',
'pelantarnya': 'lantar',
'pelantaran': 'pelantar',
'melantarkan': 'lantar',
'melantarkannya': 'lantar',
'melantas': 'lantas',
'berlantas': 'lantas',
'terlantas': 'lantas',
'berlantasan': 'lantas',
'melantaskan': 'lantas',
'melantik': 'lantik',
'melantiknya': 'lantik',
'melantikan': 'lantik',
'pelantik': 'lantik',
'pelantiknya': 'lantik',
'pelantikkan': 'lantik',
'pelantikkannya': 'lantik',
'pelantikan': 'lantik',
'pelantikannya': 'lantik',
'melanting': 'lanting',
'terlanting': 'lanting',
'berlanting': 'lanting',
'melantingkan': 'lanting',
'lantunan': 'lantun',
'lantunannya': 'lantun',
'melantun': 'lantun',
'melantunkan': 'lantun',
'melantunkannya': 'lantun',
'melantunan': 'lantun',
'luntang': 'lantung',
'peluntang': 'lantung',
'meluntang': 'lantung',
'lanturan': 'lantur',
'melantur': 'lantur',
'melanturkan': 'lantur',
'pelanturan': 'lantur',
'melanus': 'lanus',
'melanyah': 'lanyah',
'melanyak': 'lanyak',
'melanyau': 'lanyau',
'mengelap': 'lap',
'mengelapnya': 'lap',
'mengelapi': 'lap',
'dilapah': 'lapah',
'melapah': 'lapah',
'2 lapak': 'lapak',
'berlapak': 'lapak',
'lapangan': 'lapang',
'lapangannya': 'lapang',
'lapanganlah': 'lapang',
'lapanganan': 'lapang',
'melapangi': 'lapang',
'melapangkan': 'lapang',
'memperlapang': 'lapang',
'memperlapangkan': 'lapang',
'berlapang-lapang': 'lapang',
'dilapih': 'lapih',
'melapih': 'lapih',
'berlapih': 'lapih',
'melapik': 'lapik',
'selapik': 'lapik',
'melapiki': 'lapik',
'berlapik': 'lapik',
'melapikkan': 'lapik',
'melapis': 'lapis',
'melapisnya': 'lapis',
'melapiskan': 'lapis',
'melapisi': 'lapis',
'lapisan': 'lapis',
'lapisannya': 'lapis',
'pelapis': 'lapis',
'pelapisnya': 'lapis',
'pelapisan': 'lapis',
'melapisinya': 'lapis',
'berlapis': 'lapis',
'berlapisnya': 'lapis',
'berlapiskan': 'lapis',
'berlapisan': 'lapis',
'berlapis-lapis': 'lapis',
'laporan': 'lapor',
'laporannya': 'lapor',
'laporankan': 'lapor',
'laporanan': 'lapor',
'laporanku': 'lapor',
'laporanmu': 'lapor',
'pelapor': 'lapor',
'pelapornya': 'lapor',
'pelaporlah': 'lapor',
'pelaporkan': 'lapor',
'pelaporan': 'lapor',
'melapor': 'lapor',
'melapornya': 'lapor',
'melaporlah': 'lapor',
'melaporkan': 'lapor',
'melaporkannya': 'lapor',
'melapori': 'lapor',
'melaporan': 'lapor',
'pelaporannya': 'lapor',
'melaporkankan': 'lapor',
'melapun': 'lapun',
'melapur': 'lapur',
'berlapur': 'lapur',
'terlara-lara': 'lara',
'melarah': 'larah',
'berlarah-larah': 'larah',
'pelarai': 'larai',
'melarai': 'larai',
'melaraikan': 'larai',
'melaram': 'laram',
'larangan': 'larang',
'larangannya': 'larang',
'laranganku': 'larang',
'melarang': 'larang',
'melarangnya': 'larang',
'melarangan': 'larang',
'melarangku': 'larang',
'melarangmu': 'larang',
'terlarang': 'larang',
'terlarangnya': 'larang',
'terlarangan': 'larang',
'pelarangan': 'larang',
'pelarangannya': 'larang',
'melarangkan': 'larang',
'selarap': 'larap',
'melarapkan': 'larap',
'selaras': 'laras',
'selarasnya': 'laras',
'selaraskan': 'laras',
'selarasan': 'laras',
'melarasi': 'laras',
'pelarasan': 'laras',
'kelarasan': 'laras',
'berlarasan': 'laras',
'melaraskan': 'laras',
'melaraskannya': 'laras',
'keselarasan': 'laras',
'keselarasannya': 'laras',
'penyelarasan': 'laras',
'menyelaraskan': 'laras',
'menyelaraskannya': 'laras',
'melarat': 'larat',
'melaratnya': 'larat',
'melaratkan': 'larat',
'memperlarat': 'larat',
'berlarat-larat': 'larat',
'berlarat-laratnya': 'larat',
'melarau': 'larau',
'melarih': 'larih',
'melarihi': 'larih',
'berlarih-larih': 'larih',
'selarik': 'larik',
'pelarik': 'larik',
'melarik': 'larik',
'larikan': 'larik',
'berlarik': 'larik',
'melarikkan': 'larik',
'berlarik-larik': 'larik',
'pelaris': 'laris',
'pelarisan': 'laris',
'terlaris': 'laris',
'terlarisnya': 'laris',
'melariskan': 'laris',
'melaru': 'laru',
'melarui': 'laru',
'melarungkan': 'larung',
'pengelasan': 'las',
'melasah': 'lasah',
'pelasah': 'lasah',
'melasahkan': 'lasah',
'memperlasah': 'lasah',
'pelasak': 'lasak',
'pelasakan': 'lasak',
'pelasi': 'lasi',
'lasian': 'lasi',
'melasikan': 'lasi',
'kelaskaran': 'laskar',
'selat-latnya': 'lat',
'melata': 'lata',
'pelatah': 'latah',
'pelatahan': 'latah',
'kelatahan': 'latah',
'melatahkan': 'latah',
'melatam': 'latam',
'melatamkan': 'latam',
'melatarbelakangi': 'latar belakang',
'melatarbelakanginya': 'latar belakang',
'melatari': 'latar',
'melatarinya': 'latar',
'pelataran': 'latar',
'pelatarannya': 'latar',
'melatas': 'latas',
'melating': 'lating',
'latisan': 'latis',
'melatis': 'latis',
'melatur': 'latur',
'berlauk': 'lauk',
'lauk-pauk': 'lauk',
'lauk-pauknya': 'lauk',
'laun-laun': 'laun',
'melaun-laun': 'laun',
'melaung': 'laung',
'pelaung': 'laung',
'sepelaung': 'laung',
'melaungkan': 'laung',
'selaur': 'laur',
'melaur': 'laur',
'melawa': 'lawa',
'melawanya': 'lawa',
'melawai': 'lawa',
'melawaan': 'lawa',
'pelawa': 'lawa',
'lawah': 'lawai',
'lawahan': 'lawai',
'lawah-lawah': 'lawai',
'melawak': 'lawak',
'melawaknya': 'lawak',
'pelawak': 'lawak',
'pelawaknya': 'lawak',
'lawakan': 'lawak',
'lawakannya': 'lawak',
'lawak-lawak': 'lawak',
'melawak-lawak': 'lawak',
'berlawak-lawak': 'lawak',
'berlawalata': 'lawalata',
'pelawang': 'lawang',
'pelawangan': 'lawang',
'melawar': 'lawar',
'melawas': 'lawas',
'lawatan': 'lawat',
'lawatannya': 'lawat',
'melawat': 'lawat',
'melawatnya': 'lawat',
'melawatkan': 'lawat',
'melawati': 'lawat',
'pelawat': 'lawat',
'pelawati': 'lawat',
'pelawatan': 'lawat',
'perlawatan': 'lawat',
'perlawatannya': 'lawat',
'selawe': 'lawe',
'penglawe': 'lawe',
'lawi-lawi': 'lawi',
'melayah': 'layah',
'terlayah': 'layah',
'melayahkan': 'layah',
'melayam': 'layam',
'layanan': 'layan',
'layanannya': 'layan',
'layanani': 'layan',
'layananan': 'layan',
'pelayan': 'layan',
'pelayannya': 'layan',
'pelayani': 'layan',
'pelayanan': 'layan',
'melayani': 'layan',
'melayaninya': 'layan',
'melayanilah': 'layan',
'melayanii': 'layan',
'melayanimu': 'layan',
'pelayanannya': 'layan',
'pelayananan': 'layan',
'pelayananmu': 'layan',
'melayankan': 'layan',
'dilayang': 'layang',
'dilayangkan': 'layang',
'dilayangkannya': 'layang',
'dilayangi': 'layang',
'dilayangan': 'layang',
'melayang': 'layang',
'melayangnya': 'layang',
'melayanglah': 'layang',
'melayangkan': 'layang',
'melayangkannya': 'layang',
'melayangan': 'layang',
'selayang': 'layang',
'layangan': 'layang',
'layangannya': 'layang',
'terlayang': 'layang',
'pelayangan': 'layang',
'pelayangannya': 'layang',
'layang-layang': 'layang',
'layang-layangnya': 'layang',
'layang-layangan': 'layang',
'layang-layangku': 'layang',
'melayang-layang': 'layang',
'terlayang-layang': 'layang',
'melayap': 'layap',
'melayapi': 'layap',
'terlayap': 'layap',
'kelayapan': 'layap',
'melayapkan': 'layap',
'berlayapan': 'layap',
'melayap-layap': 'layap',
'berlayap-layapan': 'layap',
'melayap-layapkan': 'layap',
'pelayar': 'layar',
'pelayaran': 'layar',
'melayari': 'layar',
'melayarinya': 'layar',
'berlayar': 'layar',
'berlayarnya': 'layar',
'pelayarannya': 'layar',
'pelayaranan': 'layar',
'melayarkan': 'layar',
'berpelayaran': 'layar',
'melayas': 'layas',
'melayaskan': 'layas',
'pelayat': 'layat',
'pelayatnya': 'layat',
'pelayatan': 'layat',
'melayat': 'layat',
'melayatlah': 'layat',
'melayuk': 'layuk',
'melayur': 'layur',
'melayut': 'layut',
'kelaziman': 'lazim',
'kelazimannya': 'lazim',
'melazimkan': 'lazim',
'melebar': 'lebar',
'melebarnya': 'lebar',
'melebarkan': 'lebar',
'melebarkannya': 'lebar',
'melebari': 'lebar',
'selebar': 'lebar',
'selebarnya': 'lebar',
'selebari': 'lebar',
'selebaran': 'lebar',
'pelebaran': 'lebar',
'pelebarannya': 'lebar',
'memperlebar': 'lebar',
'memperlebarnya': 'lebar',
'berlebaran': 'lebaran',
'berlebaranlah': 'lebaran',
'melebas': 'lebas',
'melebat': 'lebat',
'melebatnya': 'lebat',
'melebatkan': 'lebat',
'melebih': 'lebih',
'melebihkan': 'lebih',
'melebihkannya': 'lebih',
'melebihi': 'lebih',
'terlebih': 'lebih',
'terlebihi': 'lebih',
'terlebihan': 'lebih',
'melebihinya': 'lebih',
'melebihiku': 'lebih',
'berlebih': 'lebih',
'berlebihnya': 'lebih',
'berlebihkan': 'lebih',
'berlebihi': 'lebih',
'berlebihan': 'lebih',
'kelebihan': 'lebih',
'kelebihannya': 'lebih',
'kelebihanku': 'lebih',
'kelebihanmu': 'lebih',
'berlebihannya': 'lebih',
'berlebihanlah': 'lebih',
'berlebihanan': 'lebih',
'selebihnya': 'lebih',
'lebih-lebih': 'lebih',
'lebih-lebihkan': 'lebih',
'berkelebihan': 'lebih',
'melebih-lebihi': 'lebih',
'berlebih-lebih': 'lebih',
'berlebih-lebihkan': 'lebih',
'berlebih-lebihan': 'lebih',
'terlebih-lebih': 'lebih',
'berlebih-lebihannya': 'lebih',
'melebih-lebihkan': 'lebih',
'melebih-lebihkannya': 'lebih',
'melebuhkan': 'lebuh',
'melebuk': 'lebuk',
'melebun': 'lebun',
'leburan': 'lebur',
'melebur': 'lebur',
'meleburnya': 'lebur',
'meleburkan': 'lebur',
'meleburkannya': 'lebur',
'terlebur': 'lebur',
'peleburan': 'lebur',
'peleburannya': 'lebur',
'keleburan': 'lebur',
'berlecah': 'lecah',
'terlecah': 'lecah',
'meleceh': 'leceh',
'melecehkan': 'leceh',
'melecehkannya': 'leceh',
'melecehan': 'leceh',
'peleceh': 'leceh',
'pelecehan': 'leceh',
'pelecehannya': 'leceh',
'melecek': 'lecek',
'melecekkan': 'lecek',
'melecekan': 'lecek',
'melecit': 'lecit',
'melecun': 'lecun',
'melecur': 'lecur',
'melecurkan': 'lecur',
'pelecut': 'lecut',
'pelecutnya': 'lecut',
'pelecutan': 'lecut',
'melecut': 'lecut',
'melecutnya': 'lecut',
'melecutkan': 'lecut',
'melecuti': 'lecut',
'peledak': 'ledak',
'peledaknya': 'ledak',
'peledakkan': 'ledak',
'peledakan': 'ledak',
'ledakan': 'ledak',
'ledakannya': 'ledak',
'meledak': 'ledak',
'meledaknya': 'ledak',
'meledaklah': 'ledak',
'meledakkan': 'ledak',
'meledakkannya': 'ledak',
'meledakan': 'ledak',
'peledakannya': 'ledak',
'meledakkanku': 'ledak',
'terledakkan': 'ledak',
'meledang': 'ledang',
'meledek': 'ledek',
'meledeknya': 'ledek',
'meledekkan': 'ledek',
'meledekku': 'ledek',
'meledeki': 'ledek',
'meledekiku': 'ledek',
'meleding': 'leding',
'meledos': 'ledos',
'meleduk': 'leduk',
'meledung': 'ledung',
'meledungkan': 'ledung',
'kelegaan': 'lega',
'kelegaannya': 'lega',
'melegakan': 'lega',
'melegakannya': 'lega',
'melegalkan': 'legal',
'melegalkannya': 'legal',
'melegalisasi': 'legalisasi',
'melegalisasinya': 'legalisasi',
'melegalisasikan': 'legalisasi',
'melegalisasikannya': 'legalisasi',
'melegenda': 'legenda',
'melegendanya': 'legenda',
'melegendakan': 'legenda',
'melegendaris': 'legendaris',
'melegitimasikan': 'legitimasi',
'melego': 'lego',
'melegonya': 'lego',
'melegu': 'legu',
'legum-legum': 'legum',
'berlegung': 'legung',
'berleha-leha': 'leha-leha',
'meleja': 'leja',
'pelejang': 'lejang',
'melejang': 'lejang',
'selejang': 'lejang',
'melejangkan': 'lejang',
'melejang-lejangkan': 'lejang',
'melejit': 'lejit',
'melejitnya': 'lejit',
'melejitkan': 'lejit',
'terleka': 'leka',
'melekam': 'lekam',
'melekang': 'lekang',
'melekangkan': 'lekang',
'melekap': 'lekap',
'melekapkan': 'lekap',
'melekari': 'lekar',
'melekaskan': 'lekas',
'selekasnya': 'lekas',
'selekasnyalah': 'lekas',
'lekas-lekas': 'lekas',
'memperlekas': 'lekas',
'berlekas-lekas': 'lekas',
'selekas-lekasnya': 'lekas',
'berlekas-lekasan': 'lekas',
'lekatan': 'lekat',
'lekatannya': 'lekat',
'melekat': 'lekat',
'melekatnya': 'lekat',
'melekatlah': 'lekat',
'melekatkan': 'lekat',
'melekatkannya': 'lekat',
'melekati': 'lekat',
'terlekat': 'lekat',
'melekatinya': 'lekat',
'berlekat': 'lekat',
'berlekatan': 'lekat',
'pelekatan': 'lekat',
'pelekatannya': 'lekat',
'lekat-lekat': 'lekat',
'berlekat-lekat': 'lekat',
'melekokkan': 'lekok',
'meleku': 'leku',
'melekukan': 'lekuk',
'melekuk': 'lekuk',
'melekukkan': 'lekuk',
'berlekuk': 'lekuk',
'berlekuk-lekuk': 'lekuk',
'melela': 'lela',
'melelakan': 'lela',
'berlela': 'lela',
'melelah': 'lelah',
'melelahkan': 'lelah',
'melelahkannya': 'lelah',
'kelelahan': 'lelah',
'kelelahannya': 'lelah',
'kelelahankan': 'lelah',
'memperlelah': 'lelah',
'melelai': 'lelai',
'melelaikan': 'lelai',
'melelang': 'lelang',
'melelangnya': 'lelang',
'melelangkan': 'lelang',
'pelelangan': 'lelang',
'pelelangannya': 'lelang',
'perlelangan': 'lelang',
'memperlelangkan': 'lelang',
'terlelap': 'lelap',
'terlelapnya': 'lelap',
'melelapkan': 'lelap',
'memperlelar': 'lelar',
'diperlelarkan': 'lelar',
'memperlelarkan': 'lelar',
'melelas': 'lelas',
'meleleh': 'leleh',
'melelehnya': 'leleh',
'melelehkan': 'leleh',
'melelehkannya': 'leleh',
'berlelehan': 'leleh',
'meleleh-leleh': 'leleh',
'melelepkan': 'lelep',
'meleler': 'leler',
'keleleran': 'leler',
'berleleran': 'leler',
'berlelewa': 'lelewa',
'berleluasa': 'leluasa',
'keleluasaan': 'leluasa',
'keleluasaannya': 'leluasa',
'meleluasakan': 'leluasa',
'berlelucon': 'lelucon',
'mengelem': 'lem',
'mengelemnya': 'lem',
'kelemahan': 'lemah',
'kelemahannya': 'lemah',
'kelemahanan': 'lemah',
'kelemahanku': 'lemah',
'kelemahanmu': 'lemah',
'melemahkan': 'lemah',
'melemahkannya': 'lemah',
'melemahkankan': 'lemah',
'melemahkan-mu': 'lemah',
'memperlemahkan': 'lemah',
'melemang': 'lemang',
'melemaskan': 'lemas',
'melemaskannya': 'lemas',
'melembaga': 'lembaga',
'melembaganya': 'lembaga',
'melembagakan': 'lembaga',
'melembagakannya': 'lembaga',
'berlembaga': 'lembaga',
'pelembagaan': 'lembaga',
'pelembagaannya': 'lembaga',
'kelembagaan': 'lembaga',
'kelembagaannya': 'lembaga',
'perlembagaan': 'lembaga',
'melembai': 'lembai',
'melembak': 'lembak',
'melembakan': 'lembak',
'melembang': 'lembang',
'lembaran': 'lembar',
'lembarannya': 'lembar',
'melembarkan': 'lembar',
'melembek': 'lembek',
'melembekkan': 'lembek',
'kelembekan': 'lembek',
'melembing': 'lembing',
'melembung': 'lembung',
'melembungnya': 'lembung',
'pelembungan': 'lembung',
'melembungkan': 'lembung',
'melembur': 'lembur',
'melemburkan': 'lembur',
'melempai': 'lempai',
'terlempai': 'lempai',
'berlempaian': 'lempai',
'melempang': 'lempang',
'melempangkan': 'lempang',
'melempap': 'lempap',
'lemparan': 'lempar',
'lemparannya': 'lempar',
'melempar': 'lempar',
'melemparnya': 'lempar',
'melemparlah': 'lempar',
'melemparkan': 'lempar',
'melemparkannya': 'lempar',
'melempari': 'lempar',
'melemparan': 'lempar',
'melemparku': 'lempar',
'melemparmu': 'lempar',
'pelempar': 'lempar',
'pelemparnya': 'lempar',
'pelemparan': 'lempar',
'sepelempar': 'lempar',
'sepelemparan': 'lempar',
'melemparkanku': 'lempar',
'melemparkanmu': 'lempar',
'lempar-lemparan': 'lempar',
'berlempar-lemparan': 'lempar',
'melempem': 'lempem',
'melempemnya': 'lempem',
'melempengkan': 'lempeng',
'lemping': 'lempit',
'melempit': 'lempit',
'melemping': 'lempit',
'melempuh': 'lempuh',
'berlempuk': 'lempuk',
'berlena': 'lena',
'terlena': 'lena',
'terlenanya': 'lena',
'terlenakan': 'lena',
'kelenaan': 'lena',
'berlena-lena': 'lena',
'melencangkan': 'lencang',
'melencit': 'lencit',
'melenda': 'lenda',
'melendeh': 'lendeh',
'melendot': 'lendot',
'lendotan': 'lendot',
'melendoti': 'lendot',
'lendungan': 'lendung',
'melendung': 'lendung',
'lendutan': 'lendut',
'melendut': 'lendut',
'pelengah': 'lengah',
'melengah': 'lengah',
'melengahkan': 'lengah',
'terlengah': 'lengah',
'kelengahan': 'lengah',
'kelengahannya': 'lengah',
'memperlengah': 'lengah',
'melengah-lengah': 'lengah',
'berlengah-lengah': 'lengah',
'memperlengah-lengah': 'lengah',
'memperlengah-lengahkan': 'lengah',
'melengak': 'lengak',
'terlengar': 'lengar',
'melengas': 'lengas',
'melengaskan': 'lengas',
'melengat': 'lengat',
'melenge': 'lenge',
'melenggak': 'lenggak',
'melenggakan': 'lenggak',
'melenggakkan': 'lenggak',
'berlenggek': 'lenggek',
'memperlenggekkan': 'lenggek',
'berlenggek-lenggek': 'lenggek',
'lenggak-lenggok': 'lenggok',
'lenggak-lenggoknya': 'lenggok',
'lenggok-lenggok': 'lenggok',
'berlenggok-lenggok': 'lenggok',
'berlenggak-lenggok': 'lenggok',
'melenggong': 'lenggong',
'melenggor': 'lenggor',
'melenggut': 'lenggut',
'lenggut-lenggut': 'lenggut',
'pelengkap': 'lengkap',
'pelengkapnya': 'lengkap',
'pelengkapan': 'lengkap',
'selengkap': 'lengkap',
'selengkapnya': 'lengkap',
'selengkapkan': 'lengkap',
'melengkapi': 'lengkap',
'melengkapinya': 'lengkap',
'melengkapiku': 'lengkap',
'melengkapimu': 'lengkap',
'berlengkap': 'lengkap',
'kelengkapan': 'lengkap',
'kelengkapannya': 'lengkap',
'kelengkapanan': 'lengkap',
'pelengkapannya': 'lengkap',
'perlengkapan': 'lengkap',
'perlengkapannya': 'lengkap',
'perlengkapanmu': 'lengkap',
'berlengkapan': 'lengkap',
'melengkapkan': 'lengkap',
'memperlengkapi': 'lengkap',
'memperlengkapinya': 'lengkap',
'berlengkesa': 'lengkesa',
'melengket': 'lengket',
'melengketkan': 'lengket',
'berlengket': 'lengket',
'terlengket': 'lengket',
'lengket-lengket': 'lengket',
'melengking': 'lengking',
'belengkok': 'lengkok',
'berlengkok': 'lengkok',
'belengkokan': 'lengkok',
'berlengkokan': 'lengkok',
'lengkungan': 'lengkung',
'lengkungannya': 'lengkung',
'melengkung': 'lengkung',
'melengkungnya': 'lengkung',
'melengkungkan': 'lengkung',
'pelengkung': 'lengkung',
'pelengkungan': 'lengkung',
'melengkungi': 'lengkung',
'terlengkung': 'lengkung',
'kelengkungan': 'lengkung',
'kelengkungannya': 'lengkung',
'melengkur': 'lengkur',
'melengos': 'lengos',
'melengser': 'lengser',
'melengserkan': 'lengser',
'melengserkannya': 'lengser',
'belengset': 'lengset',
'melenguh': 'lenguh',
'melengung': 'lengung',
'melenja': 'lenja',
'melenjan': 'lenjan',
'berlenso': 'lenso',
'melentang': 'lentang',
'terlentang': 'lentang',
'terlentangnya': 'lentang',
'lentang-lentung': 'lentang',
'melentik': 'lentik',
'melentikkan': 'lentik',
'melentikkannya': 'lentik',
'melentikan': 'lentik',
'melenting': 'lenting',
'melentingnya': 'lenting',
'melentingkan': 'lenting',
'berlenting': 'lenting',
'kelentingan': 'lenting',
'lentang-lentok': 'lentok',
'melentuk': 'lentuk',
'terlentuk': 'lentuk',
'melentukkan': 'lentuk',
'melentung': 'lentung',
'telentung': 'lentung',
'melentur': 'lentur',
'melenturnya': 'lentur',
'melenturkan': 'lentur',
'melenturkannya': 'lentur',
'pelenturan': 'lentur',
'pelenturannya': 'lentur',
'kelenturan': 'lentur',
'kelenturannya': 'lentur',
'melenyeh': 'lenyeh',
'melenyut': 'lenyut',
'meleot': 'leot',
'melepa': 'lepa',
'melepakan': 'lepa',
'terlepa': 'lepa',
'lepa-lepa': 'lepa',
'melepak': 'lepak',
'terlepap': 'lepap',
'melepek': 'lepek',
'melepes': 'lepes',
'melepih': 'lepih',
'melepit': 'lepit',
'melepoh': 'lepoh',
'terlepoh': 'lepoh',
'melepoti': 'lepot',
'berlepotan': 'lepot',
'melepuh': 'lepuh',
'melepuhnya': 'lepuh',
'melepuhkan': 'lepuh',
'pelepuhan': 'lepuh',
'melepur': 'lepur',
'pelerai': 'lerai',
'peleraian': 'lerai',
'leraian': 'lerai',
'meleraikan': 'lerai',
'meleraikannya': 'lerai',
'terleraikan': 'lerai',
'melerak': 'lerak',
'melerakan': 'lerak',
'melerakkan': 'lerak',
'lerang-lerang': 'lerang',
'melereng': 'lereng',
'lerengan': 'lereng',
'berlereng': 'lereng',
'lereng-lereng': 'lereng',
'lereng-lerengnya': 'lereng',
'leret': 'leri',
'leretan': 'leri',
'seleret': 'leri',
'meleret': 'leri',
'berleret': 'leri',
'meleretkan': 'leri',
'berleret-leret': 'leri',
'melerok': 'lerok',
'berlerot': 'lerot',
'melesak': 'lesak',
'melesakkan': 'lesak',
'melesakkannya': 'lesak',
'melesakan': 'lesak',
'melesang': 'lesang',
'pelesapan': 'lesap',
'pelesapannya': 'lesap',
'melesapkan': 'lesap',
'lesehan': 'leseh',
'lesehannya': 'leseh',
'berlesehan': 'leseh',
'melesing': 'lesing',
'belesir': 'lesir',
'berlesir': 'lesir',
'melesit': 'lesit',
'pelesit': 'lesit',
'melesot': 'lesot',
'pelestari': 'lestari',
'pelestarikan': 'lestari',
'pelestarian': 'lestari',
'kelestarian': 'lestari',
'kelestariannya': 'lestari',
'pelestariannya': 'lestari',
'melestarikan': 'lestari',
'melestarikannya': 'lestari',
'meletakan': 'letak',
'meletakannya': 'leta',
'letah-letai': 'letai',
'meletak': 'letak',
'meletakkan': 'letak',
'meletakkannya': 'letak',
'terletak': 'letak',
'terletaknya': 'letak',
'terletaklah': 'letak',
'terletakan': 'letak',
'peletakan': 'letak',
'peletakannya': 'letak',
'meletakkanku': 'letak',
'meletakkanmu': 'letak',
'beleter': 'leter',
'peleter': 'leter',
'meleter': 'leter',
'meleterkan': 'leter',
'meletik': 'letik',
'meleting': 'leting',
'berleting': 'leting',
'meletis': 'letis',
'meletos': 'letos',
'letuk-letuk': 'letuk',
'letum-letum': 'letum',
'letupan': 'letup',
'letupannya': 'letup',
'meletup': 'letup',
'meletupnya': 'letup',
'meletuplah': 'letup',
'meletupkan': 'letup',
'meletupkannya': 'letup',
'peletup': 'letup',
'peletupan': 'letup',
'letup-letup': 'letup',
'letusan': 'letus',
'letusannya': 'letus',
'meletus': 'letus',
'meletusnya': 'letus',
'meletuslah': 'letus',
'meletuskan': 'letus',
'meletuskannya': 'letus',
'meletusi': 'letus',
'meletusan': 'letus',
'peletusan': 'letus',
'melever': 'lever',
'melewa': 'lewa',
'melewakan': 'lewa',
'melewai': 'lewa',
'melewar': 'lewar',
'melewari': 'lewar',
'melewarkan': 'lewar',
'lewat waktu': 'terlewat',
'leyeh-leyeh': 'leyeh',
'meleyot': 'leyot',
'berlezat': 'lezat',
'kelezatan': 'lezat',
'kelezatannya': 'lezat',
'melezatkan': 'lezat',
'liang-liut': 'liang',
'liang-liuk': 'liang',
'berliang-liuk': 'liang',
'liaran': 'liar',
'liarannya': 'liar',
'meliat': 'liat',
'meliatkan': 'liat',
'meliau': 'liau',
'melibas': 'libas',
'melibasnya': 'libas',
'pelibasan': 'libas',
'melibat': 'libat',
'melibatnya': 'libat',
'melibatkan': 'libat',
'melibatkannya': 'libat',
'melibati': 'libat',
'melibatan': 'libat',
'berlibat': 'libat',
'terlibat': 'libat',
'terlibatnya': 'libat',
'terlibatlah': 'libat',
'terlibatkan': 'libat',
'terlibatan': 'libat',
'pelibatan': 'libat',
'pelibatannya': 'libat',
'melibatkankan': 'libat',
'melibatkanku': 'libat',
'keterlibatan': 'libat',
'keterlibatannya': 'libat',
'keterlibatanan': 'libat',
'keterlibatanku': 'libat',
'keterlibatanmu': 'libat',
'berlibat-libat': 'libat',
'peliberalan': 'liberal',
'meliberalisasi': 'liberalisasi',
'meliberalisasikan': 'liberalisasi',
'pelicin': 'licin',
'pelicinnya': 'licin',
'kelicinan': 'licin',
'kelicinannya': 'licin',
'melicinkan': 'licin',
'melicinkannya': 'licin',
'berlidah': 'lidah',
'melidahkan': 'lidah',
'berligar-ligar': 'ligar',
'meligas': 'ligas',
'meligat': 'ligat',
'meligih': 'ligih',
'kelihaian': 'lihai',
'kelihaiannya': 'lihai',
'berlik': 'lik',
'melikas': 'likas',
'berliku-liku': 'liku',
'berliku-likunya': 'liku',
'melikuidasi': 'likuidasi',
'melikuidasinya': 'likuidasi',
'melikuidasikan': 'likuidasi',
'likuran': 'likur',
'berlikur-likur': 'likur',
'melikut': 'likut',
'melikuti': 'likut',
'berlikut': 'likut',
'melilah': 'lilah',
'melilau': 'lilau',
'melilin': 'lilin',
'lilitan': 'lilit',
'lilitannya': 'lilit',
'melilit': 'lilit',
'melilitnya': 'lilit',
'melilitkan': 'lilit',
'melilitkannya': 'lilit',
'meliliti': 'lilit',
'melilitku': 'lilit',
'selilit': 'lilit',
'selilitan': 'lilit',
'berlilit': 'lilit',
'berlilitkan': 'lilit',
'berlima': 'lima',
'seperlima': 'lima',
'seperlimanya': 'lima',
'limasan': 'limas',
'pelimau': 'limau',
'berlimau': 'limau',
'melimaui': 'limau',
'pelimbahan': 'limbah',
'melimbai': 'limbai',
'melimbaikan': 'limbai',
'berlimbak-limbak': 'limbak',
'melimbang': 'limbang',
'pelimbang': 'limbang',
'limbukan': 'limbuk',
'limbungan': 'limbung',
'melimbur': 'limbur',
'dilimbur': 'limbur',
'berlimpa': 'limpa',
'limpahan': 'limpah',
'limpahannya': 'limpah',
'melimpah': 'limpah',
'melimpahnya': 'limpah',
'melimpahlah': 'limpah',
'melimpahkan': 'limpah',
'melimpahkannya': 'limpah',
'melimpahi': 'limpah',
'melimpahan': 'limpah',
'melimpahinya': 'limpah',
'kelimpahan': 'limpah',
'kelimpahannya': 'limpah',
'pelimpahan': 'limpah',
'pelimpahannya': 'limpah',
'melimpah-limpah': 'limpah',
'berlimpah-limpah': 'limpah',
'berlimpap': 'limpap',
'berlimpap-limpap': 'limpap',
'terlimpas': 'limpas',
'melimpaui': 'limpau',
'memperlimpitkan': 'limpit',
'berlimpit-limpit': 'limpit',
'limunan': 'limun',
'melimut': 'limut',
'berlinang': 'linang',
'berlinangnya': 'linang',
'berlinangkan': 'linang',
'berlinangan': 'linang',
'berlinang-linang': 'linang',
'selincam': 'lincam',
'melincam': 'lincam',
'terlincir': 'lincir',
'melincirkan': 'lincir',
'berlindak-lindak': 'lindak',
'melindang': 'lindang',
'melindangkan': 'lindang',
'melindap': 'lindap',
'lindas': 'lindi',
'lindasan': 'lindi',
'pelindas': 'lindi',
'pelindasan': 'lindi',
'melindas': 'lindi',
'melindasnya': 'lindi',
'melindaskan': 'lindi',
'melindasi': 'lindi',
'melindasku': 'lindi',
'melindik': 'lindik',
'melindis': 'lindis',
'pelindis': 'lindis',
'melindur': 'lindur',
'melingar': 'lingar',
'melingarkan': 'lingar',
'melingari': 'lingar',
'linggisan': 'linggis',
'melinggis': 'linggis',
'lingkaran': 'lingkar',
'lingkarannya': 'lingkar',
'melingkar': 'lingkar',
'melingkarnya': 'lingkar',
'melingkarkan': 'lingkar',
'melingkarkannya': 'lingkar',
'melingkari': 'lingkar',
'melingkarinya': 'lingkar',
'terlingkar': 'lingkar',
'berlingkar': 'lingkar',
'melingkis': 'lingkis',
'selingkung': 'lingkung',
'selingkungan': 'lingkung',
'melingkung': 'lingkung',
'melingkungi': 'lingkung',
'lingkungan': 'lingkung',
'lingkungannya': 'lingkung',
'lingkunganlah': 'lingkung',
'lingkunganan': 'lingkung',
'lingkunganku': 'lingkung',
'lingkunganmu': 'lingkung',
'terlingkung': 'lingkung',
'melingkunginya': 'lingkung',
'melingkup': 'lingkup',
'melingkupi': 'lingkup',
'melingkupinya': 'lingkup',
'melingkupiku': 'lingkup',
'terlingkup': 'lingkup',
'terlingkupi': 'lingkup',
'kelinglungan': 'linglung',
'melinglungkan': 'linglung',
'melingsirkan': 'lingsir',
'kelinieran': 'linier',
'melinjak': 'linjak',
'melinjaknya': 'linjak',
'melintah': 'lintah',
'lintangan': 'lintang',
'melintang': 'lintang',
'melintangnya': 'lintang',
'melintangkan': 'lintang',
'melintangkannya': 'lintang',
'melintangi': 'lintang',
'terlintang': 'lintang',
'lintang pukang': 'lintangan',
'selintas': 'lintas',
'selintasan': 'lintas',
'lintasan': 'lintas',
'lintasannya': 'lintas',
'pelintas': 'lintas',
'pelintasan': 'lintas',
'melintas': 'lintas',
'melintasnya': 'lintas',
'melintaslah': 'lintas',
'melintaskan': 'lintas',
'melintasi': 'lintas',
'melintasinya': 'lintas',
'terlintas': 'lintas',
'terlintasnya': 'lintas',
'terlintaslah': 'lintas',
'terlintasi': 'lintas',
'pelintasannya': 'lintas',
'kelintasan': 'lintas',
'perlintasan': 'lintas',
'perlintasannya': 'lintas',
'melinting': 'linting',
'lintingan': 'linting',
'lintingannya': 'linting',
'pelintingan': 'linting',
'melintir': 'lintir',
'melintirnya': 'lintir',
'pelintuh': 'lintuh',
'melintup': 'lintup',
'melinyak': 'linyak',
'berlinyak': 'linyak',
'melinyar': 'linyar',
'berlipat ganda': 'lipat ganda',
'melipatgandakan': 'lipat ganda',
'melipatgandakannya': 'lipat ganda',
'lipatan': 'lipat',
'lipatannya': 'lipat',
'melipat': 'lipat',
'melipatnya': 'lipat',
'melipatkan': 'lipat',
'melipati': 'lipat',
'melipatan': 'lipat',
'pelipat': 'lipat',
'pelipatnya': 'lipat',
'pelipatan': 'lipat',
'berlipat': 'lipat',
'berlipatnya': 'lipat',
'berlipatlah': 'lipat',
'kelipatan': 'lipat',
'kelipatannya': 'lipat',
'peliputan': 'lipat',
'peliputannya': 'lipat',
'perlipatan': 'lipat',
'lipat-melipat': 'lipat',
'berlipat-lipat': 'lipat',
'pelipit': 'lipit',
'pelipitan': 'lipit',
'melipit': 'lipit',
'melipitnya': 'lipit',
'melipiti': 'lipit',
'melipur': 'lipur',
'pelipur': 'lipur',
'melipurkan': 'lipur',
'meliput': 'liput',
'meliputnya': 'liput',
'meliputi': 'liput',
'meliputan': 'liput',
'liputan': 'liput',
'liputannya': 'liput',
'meliputinya': 'liput',
'meliputii': 'liput',
'terliput': 'liput',
'terliputi': 'liput',
'lirikan': 'lirik',
'lirikannya': 'lirik',
'melirik': 'lirik',
'meliriknya': 'lirik',
'melirikkan': 'lirik',
'melirikan': 'lirik',
'melirikmu': 'lirik',
'selirik': 'lirik',
'melisankan': 'lisan',
'berlistrik': 'listrik',
'kelistrikan': 'listrik',
'kelistrikannya': 'listrik',
'perlistrikan': 'listrik',
'perlistrikannya': 'listrik',
'melisutkan': 'lisut',
'literan': 'liter',
'literannya': 'liter',
'literanlah': 'liter',
'melitsus': 'litsus',
'meliuk': 'liuk',
'meliuknya': 'liuk',
'meliuklah': 'liuk',
'meliukkan': 'liuk',
'meliukan': 'liuk',
'terliuk': 'liuk',
'meliuki': 'liuk',
'sepeliuk': 'liuk',
'meliuk-liuk': 'liuk',
'meliuk-liukkan': 'liuk',
'meliuk-liukkannya': 'liuk',
'meliuk-liukan': 'liuk',
'terliuk-liuk': 'liuk',
'meliuri': 'liur',
'berliur': 'liur',
'liat-liut': 'liut',
'meloak': 'loak',
'meloakkannya': 'loak',
'loakan': 'loak',
'meloakkan': 'loak',
'pelobi': 'lobi',
'pelobinya': 'lobi',
'pelobian': 'lobi',
'melobi': 'lobi',
'melobinya': 'lobi',
'melocok': 'locok',
'pelocok': 'locok',
'melocot': 'locot',
'loh jinawi': 'loh',
'meloka': 'loka',
'berlokakarya': 'lokakarya',
'melokalkan': 'lokal',
'melokalisasi': 'lokalisasi',
'melokalisasikan': 'lokalisasi',
'terlokalisasi': 'lokalisasi',
'terlokalisasikan': 'lokalisasi',
'melokap': 'lokap',
'berlokasi': 'lokasi',
'berlokasinya': 'lokasi',
'berlokasikan': 'lokasi',
'meloloh': 'loloh',
'melolong': 'lolong',
'terlolong': 'lolong',
'melolong-lolong': 'lolong',
'terlolong-lolong': 'lolong',
'meloloskan': 'lolos',
'meloloskannya': 'lolos',
'berlomba': 'lomba',
'berlombanya': 'lomba',
'berlombalah': 'lomba',
'perlombaan': 'lomba',
'perlombaannya': 'lomba',
'berlomba-lomba': 'lomba',
'berlomba-lombalah': 'lomba',
'memperlombakan': 'lomba',
'melombar': 'lombar',
'melombong': 'lombong',
'pelombongan': 'lombong',
'melomot': 'lomot',
'melompat': 'lompat',
'melompatnya': 'lompat',
'melompatlah': 'lompat',
'melompatkan': 'lompat',
'melompati': 'lompat',
'pelompat': 'lompat',
'pelompatan': 'lompat',
'lompatan': 'lompat',
'lompatannya': 'lompat',
'lompatanku': 'lompat',
'lompatanmu': 'lompat',
'melompatinya': 'lompat',
'terlompat': 'lompat',
'terlompati': 'lompat',
'sepelompat': 'lompat',
'berlompatan': 'lompat',
'sepelompatan': 'lompat',
'melompat-lompat': 'lompat',
'melompat-lompatlah': 'lompat',
'berlompok-lompok': 'lompok',
'melompong': 'lompong',
'melompongnya': 'lompong',
'meloncat': 'loncat',
'meloncatnya': 'loncat',
'meloncatlah': 'loncat',
'meloncati': 'loncat',
'loncatan': 'loncat',
'loncatannya': 'loncat',
'loncatanku': 'loncat',
'meloncatkan': 'loncat',
'berloncatan': 'loncat',
'meloncat-loncat': 'loncat',
'berloncat-loncatan': 'loncat',
'melonceng': 'lonceng',
'meloncer': 'loncer',
'melonco-lonco': 'lonco',
'melondong': 'londong',
'melondongkan': 'londong',
'meloneng': 'loneng',
'melongak-longok': 'longak-longok',
'longitudinal': 'longmars',
'melongo': 'longo',
'melongokan': 'longo',
'melongok': 'longok',
'melongoknya': 'longok',
'melongokkan': 'longok',
'terlongong-longong': 'longong',
'melonjak': 'lonjak',
'melonjaknya': 'lonjak',
'melonjaklah': 'lonjak',
'melonjakkan': 'lonjak',
'melonjakan': 'lonjak',
'terlonjak': 'lonjak',
'pelonjakan': 'lonjak',
'melonjak-lonjak': 'lonjak',
'melonjak-lonjakkan': 'lonjak',
'lonjoran': 'lonjor',
'terlonsong': 'lonsong',
'melontai': 'lontai',
'melontar': 'lontar',
'melontarnya': 'lontar',
'melontarkan': 'lontar',
'melontarkannya': 'lontar',
'melontari': 'lontar',
'lontaran': 'lontar',
'lontarannya': 'lontar',
'pelontar': 'lontar',
'pelontarnya': 'lontar',
'pelontaran': 'lontar',
'sepelontar': 'lontar',
'berlontaran': 'lontar',
'melontarkankan': 'lontar',
'berlopak': 'lopak',
'lopak-lopak': 'lopak',
'lopak-lapik': 'lopak',
'berlopak-lopak': 'lopak',
'melorot': 'lorot',
'melorotnya': 'lorot',
'melorotkan': 'lorot',
'meloroti': 'lorot',
'mengeloskan': 'los',
'meloso': 'loso',
'melotrekan': 'lotre',
'melotrekannya': 'lotre',
'lowongan': 'lowong',
'lowongannya': 'lowong',
'melowongkan': 'lowong',
'meloya': 'loya',
'keloyoan': 'loyo',
'meloyong': 'loyong',
'meluah': 'luah',
'meluahkan': 'luah',
'meluaki': 'luak',
'meluang': 'luang',
'meluangkan': 'luang',
'meluangkannya': 'luang',
'meluangan': 'luang',
'peluang': 'luang',
'peluangnya': 'luang',
'peluanglah': 'luang',
'peluangan': 'luang',
'peluangku': 'luang',
'peluangmu': 'luang',
'terluang': 'luang',
'keluangan': 'luang',
'meluangkankan': 'luang',
'meluap': 'luap',
'meluapnya': 'luap',
'meluaplah': 'luap',
'meluapkan': 'luap',
'meluapkannya': 'luap',
'meluapi': 'luap',
'luapan': 'luap',
'luapannya': 'luap',
'luaran': 'luar',
'luarannya': 'luar',
'meluar': 'luar',
'meluarkan': 'luar',
'meluarkannya': 'luar',
'meluat': 'luat',
'meluber': 'luber',
'melubernya': 'luber',
'meluberkan': 'luber',
'meluberi': 'luber',
'melucu': 'lucu',
'melucunya': 'lucu',
'berlucu': 'lucu',
'kelucuan': 'lucu',
'kelucuannya': 'lucu',
'melucup': 'lucup',
'melucut': 'lucut',
'melucuti': 'lucut',
'lucutan': 'lucut',
'terlucut': 'lucut',
'terlucuti': 'lucut',
'melucutinya': 'lucut',
'melucutkan': 'lucut',
'perlucutan': 'lucut',
'kelugasan': 'lugas',
'kelugasannya': 'lugas',
'keluguan': 'lugu',
'keluguannya': 'lugu',
'keluhuran': 'luhur',
'keluhurannya': 'luhur',
'meluhurkan': 'luhur',
'meluik': 'luik',
'berluk': 'luk',
'melukai': 'luka',
'melukainya': 'luka',
'melukaiku': 'luka',
'melukaimu': 'luka',
'terluka': 'luka',
'terlukanya': 'luka',
'terlukai': 'luka',
'pelukaan': 'luka',
'perlukaan': 'luka',
'melukah': 'lukah',
'melukat': 'lukat',
'lukisan': 'lukis',
'lukisannya': 'lukis',
'lukisanku': 'lukis',
'lukisanmu': 'lukis',
'pelukis': 'lukis',
'pelukisnya': 'lukis',
'pelukisan': 'lukis',
'pelukismu': 'lukis',
'melukis': 'lukis',
'melukisnya': 'lukis',
'melukiskan': 'lukis',
'melukiskannya': 'lukis',
'melukisi': 'lukis',
'melukisan': 'lukis',
'terlukis': 'lukis',
'terlukiskan': 'lukis',
'meluku': 'luku',
'melukukan': 'luku',
'meluli': 'luli',
'luluhan': 'luluh',
'meluluhkan': 'luluh',
'meluluhkannya': 'luluh',
'meluluhlantakkan': 'luluh lantak',
'meluluhlantakkannya': 'luluh lantak',
'meluluk': 'luluk',
'melulukan': 'luluk',
'peluluk': 'luluk',
'pelulukan': 'luluk',
'terluluk': 'luluk',
'berluluk': 'luluk',
'melulum': 'lulum',
'melulur': 'lulur',
'melulurkan': 'lulur',
'meluluri': 'lulur',
'selulus': 'lulus',
'selulusnya': 'lulus',
'lulusan': 'lulus',
'lulusannya': 'lulus',
'melulusi': 'lulus',
'kelulusan': 'lulus',
'kelulusannya': 'lulus',
'kelulusanmu': 'lulus',
'selulusan': 'lulus',
'meluluskan': 'lulus',
'meluluskannya': 'lulus',
'melulut': 'lulut',
'pelulut': 'lulut',
'berlulut': 'lulut',
'berlumang': 'lumang',
'melumangkan': 'lumang',
'melumari': 'lumar',
'berlumar': 'lumar',
'pelumas': 'lumas',
'pelumasnya': 'lumas',
'pelumaslah': 'lumas',
'pelumasan': 'lumas',
'melumas': 'lumas',
'melumaskan': 'lumas',
'melumasi': 'lumas',
'lumatan': 'lumat',
'pelumat': 'lumat',
'melumatkan': 'lumat',
'melumatkannya': 'lumat',
'lumayan': 'lumbago',
'lumayanlah': 'lumbago',
'melumer': 'lumer',
'melumerkan': 'lumer',
'melumeri': 'lumer',
'pelumer': 'lumer',
'pelumeran': 'lumer',
'melumpukkan': 'lumpuk',
'kelumrahan': 'lumrah',
'berlumus': 'lumus',
'pelunak': 'lunak',
'pelunakan': 'lunak',
'melunak': 'lunak',
'melunaknya': 'lunak',
'melunakkan': 'lunak',
'melunakkannya': 'lunak',
'melunakan': 'lunak',
'melunaki': 'lunak',
'kelunakan': 'lunak',
'memperlunak': 'lunak',
'lunasan': 'lunas',
'melunasi': 'lunas',
'melunasinya': 'lunas',
'melunaskan': 'lunas',
'melunaskannya': 'lunas',
'pelunauan': 'lunau',
'meluncungkan': 'luncung',
'peluncur': 'luncur',
'peluncurnya': 'luncur',
'peluncurkan': 'luncur',
'peluncurkannya': 'luncur',
'peluncuran': 'luncur',
'meluncur': 'luncur',
'meluncurnya': 'luncur',
'meluncurlah': 'luncur',
'meluncurkan': 'luncur',
'meluncurkannya': 'luncur',
'meluncuran': 'luncur',
'meluncuri': 'luncur',
'terluncur': 'luncur',
'peluncurannya': 'luncur',
'berseluncur': 'luncur',
'meluncurkankan': 'luncur',
'pelungguh': 'lungguh',
'melungguh': 'lungguh',
'terlungsar': 'lungsar',
'lungsungan': 'lungsung',
'melungsung': 'lungsung',
'lungsuran': 'lungsur',
'melungsur': 'lungsur',
'melungsurkan': 'lungsur',
'terlunjur': 'lunjur',
'berlunjur': 'lunjur',
'melunjurkan': 'lunjur',
'terlunta': 'lunta',
'terluntanya': 'lunta',
'terlunta-lunta': 'lunta',
'terlunta-luntanya': 'lunta',
'peluntur': 'luntur',
'pelunturan': 'luntur',
'meluntur': 'luntur',
'melunturnya': 'luntur',
'melunturkan': 'luntur',
'melunturi': 'luntur',
'kelunturan': 'luntur',
'melunyah': 'lunyah',
'pelupa': 'lupa',
'pelupanya': 'lupa',
'terlupa': 'lupa',
'terlupakan': 'lupa',
'terlupakannya': 'lupa',
'melupai': 'lupa',
'kelupaan': 'lupa',
'melupakan': 'lupa',
'melupakannya': 'lupa',
'melupakanku': 'lupa',
'melupakanmu': 'lupa',
'lupa-lupaan': 'lupa',
'lupa-lupa ingat': 'lupa',
'pelupuh': 'lupuh',
'melupuh': 'lupuh',
'melupuhkan': 'lupuh',
'terluput': 'luput',
'terluputkan': 'luput',
'meluputkan': 'luput',
'berlurah': 'lurah',
'kelurahan': 'lurah',
'kelurahannya': 'lurah',
'kelurahani': 'lurah',
'kelurahanan': 'lurah',
'meluru': 'luru',
'melurukan': 'luru',
'luruban': 'lurub',
'melurubi': 'lurub',
'meluruh': 'luruh',
'meluruhnya': 'luruh',
'meluruhkan': 'luruh',
'meluruhkannya': 'luruh',
'peluruh': 'luruh',
'peluruhnya': 'luruh',
'peluruhan': 'luruh',
'peluruhannya': 'luruh',
'melurut': 'lurut',
'berlusin': 'lusin',
'berlusin-lusin': 'lusin',
'melusuh': 'lusuh',
'kelusuhan': 'lusuh',
'kelusuhannya': 'lusuh',
'melusuhkan': 'lusuh',
'meluti': 'luti',
'melutu': 'lutu',
'berlutu': 'lutu',
'bersilutu': 'lutu',
'meluwengkan': 'luweng',
'keluwesan': 'luwes',
'keluwesannya': 'luwes',
'meluweskan': 'luwes',
'meluyut': 'luyut',
'berluyutan': 'luyut',
'pemaaf': 'maaf',
'pemaafnya': 'maaf',
'pemaafan': 'maaf',
'memaafi': 'maaf',
'pemaafannya': 'maaf',
'permaafan': 'maaf',
'memaafkan': 'maaf',
'memaafkannya': 'maaf',
'memaafkanlah': 'maaf',
'memaafkanku': 'maaf',
'memaafkanmu': 'maaf',
'maaf-memaafkan': 'maaf',
'bermaaf-maafan': 'maaf',
'dimabuk': 'mabuk',
'dimabukkan': 'mabuk',
'pemabuk': 'mabuk',
'memabukkan': 'mabuk',
'mabuk-mabukan': 'mabuk',
'mabuk-mabukannya': 'mabuk',
'bermabuk-mabukan': 'mabuk',
'mabul-mabul': 'mabul',
'semacam': 'macam',
'semacamnya': 'macam',
'semacaman': 'macam',
'semacamnyalah': 'macam',
'bermacam': 'macam',
'macam-macam': 'macam',
'macam-macamnya': 'macam',
'macam-macamlah': 'macam',
'bermacam-macam': 'macam',
'bermacam-macamlah': 'macam',
'mempermacam-macamkan': 'macam',
'memacani': 'macan',
'macan-macanan': 'macan',
'pemacet': 'macet',
'kemacetan': 'macet',
'kemacetannya': 'macet',
'kemacetanlah': 'macet',
'kemacetankan': 'macet',
'kemacetanan': 'macet',
'memacetkan': 'macet',
'pemadah': 'madah',
'bermadah': 'madah',
'memadahkan': 'madah',
'bermadat': 'madat',
'bermadu': 'madu',
'memadui': 'madu',
'permaduan': 'madu',
'mempermadukan': 'madu',
'memafhumi': 'mafhum',
'pemafiaan': 'mafia',
'bermagang': 'magang',
'permahadutaan': 'mahaduta',
'kemahalan': 'mahal',
'kemahalannya': 'mahal',
'memahalkan': 'mahal',
'kemaharajaan': 'maharaja',
'bersimaharajalela': 'maharajalela',
'kemahasiswaan': 'mahasiswa',
'kemahasiswaannya': 'mahasiswa',
'memahfuzkan': 'mahfuz',
'memahkotai': 'mahkota',
'memahkotainya': 'mahkota',
'bermahkota': 'mahkota',
'bermahkotakan': 'mahkota',
'pemahkotaan': 'mahkota',
'mainan': 'main',
'mainannya': 'main',
'mainanlah': 'main',
'mainani': 'main',
'mainanan': 'main',
'mainanku': 'main',
'mainanmu': 'main',
'pemain': 'main',
'pemainnya': 'main',
'pemainlah': 'main',
'pemaini': 'main',
'pemainan': 'main',
'pemainku': 'main',
'pemainmu': 'main',
'bermain': 'main',
'bermainnya': 'main',
'bermainlah': 'main',
'bermainkan': 'main',
'bermaini': 'main',
'bermainan': 'main',
'bermainku': 'main',
'bermainmu': 'main',
'memainkan': 'main',
'memainkannya': 'main',
'memainkankan': 'main',
'memainkannyalah': 'main',
'memainkanku': 'main',
'memainkanmu': 'main',
'main-main': 'main',
'main-mainnya': 'main',
'main-mainlah': 'main',
'main-mainkan': 'main',
'main-mainan': 'main',
'permainan': 'main',
'permainannya': 'main',
'permainanlah': 'main',
'permainani': 'main',
'permainanan': 'main',
'permainannyalah': 'main',
'permainanku': 'main',
'permainanmu': 'main',
'sepermainan': 'main',
'sepermainannya': 'main',
'bermain-main': 'main',
'bermain-mainlah': 'main',
'mempermainkan': 'main',
'mempermainkannya': 'main',
'mempermainkanku': 'main',
'memajalkan': 'majal',
'kemajemukan': 'majemuk',
'kemajemukannya': 'majemuk',
'kemajiran': 'majir',
'memajuh': 'pajuh',
'pemakalah': 'makalah',
'bermakam': 'makam',
'pemakaman': 'makam',
'pemakamannya': 'makam',
'pemakamanlah': 'makam',
'pemakamanan': 'makam',
'pemakamanku': 'makam',
'permakaman': 'makam',
'permakamannya': 'makam',
'memakamkan': 'makam',
'memakamkannya': 'makam',
'memakbulkan': 'makbul',
'memaki': 'maki',
'memakinya': 'maki',
'memakilah': 'maki',
'memakian': 'maki',
'memakiku': 'maki',
'memakimu': 'maki',
'makian': 'maki',
'makiannya': 'maki',
'memaki-maki': 'maki',
'memaki-makinya': 'maki',
'maki-makian': 'maki',
'semakin': 'makin',
'semakini': 'makin',
'memaklumi': 'maklum',
'memakluminya': 'maklum',
'pemakluman': 'maklum',
'pemaklumannya': 'maklum',
'memaklumkan': 'maklum',
'mempermaklumkan': 'maklum',
'memaklumatkan': 'maklumat',
'bermakmum': 'makmum',
'memakmumi': 'makmum',
'bermakrifat': 'makrifat',
'kemaksiatan': 'maksiat',
'kemaksiatannya': 'maksiat',
'kemaksimalan': 'maksimal',
'semaksimalnya': 'maksimal',
'memaksimalkan': 'maksimal',
'memaksimalkannya': 'maksimal',
'semaksimal mungkin': 'maksimal',
'semaksimal-maksimalnya': 'maksimal',
'termaktub': 'maktub',
'termaktubkan': 'maktub',
'pemakzulan': 'makzul',
'pemakzulannya': 'makzul',
'memakzulkan': 'makzul',
'memakzulkannya': 'makzul',
'termala': 'mala',
'malahan': 'malah',
'memalai': 'palai',
'malai-malai': 'malai',
'bermalaikan': 'malai',
'memalangi': 'palang',
'kemalangan': 'malang',
'kemalangannya': 'malang',
'malaran': 'malar',
'malar-malar': 'malar',
'pemaling': 'maling',
'memaling': 'maling',
'memalingkan': 'paling',
'memalingkannya': 'paling',
'kemalingan': 'maling',
'pemalu': 'malu',
'pemalunya': 'malu',
'pemaluan': 'malu',
'pemalumu': 'malu',
'memalui': 'palu',
'bermalu': 'malu',
'kemaluan': 'malu',
'kemaluannya': 'malu',
'kemaluanku': 'malu',
'kemaluanmu': 'malu',
'memalukan': 'palu',
'memalukannya': 'palu',
'malu-malu': 'malu',
'malu-malunya': 'malu',
'malu-malui': 'malu',
'kemalu-maluan': 'malu',
'mempermalukan': 'malu',
'mempermalukannya': 'malu',
'mamahan': 'mamah',
'mamahani': 'mamah',
'memamah': 'mamah',
'memamahi': 'mamah',
'pemamah': 'mamah',
'pemamahan': 'mamah',
'memamahkan': 'mamah',
'bermamai': 'mamai',
'semampu': 'mampu',
'semampunya': 'mampu',
'semampuku': 'mampu',
'semampumu': 'mampu',
'kemampuan': 'mampu',
'kemampuannya': 'mampu',
'kemampuanlah': 'mampu',
'kemampuanku': 'mampu',
'kemampuanmu': 'mampu',
'berkemampuan': 'mampu',
'mana-mana': 'mana',
'mana-mananya': 'mana',
'bermanah': 'manah',
'memanajemeni': 'manajemen',
'memanau': 'manau',
'termandam': 'mandam',
'kemandekan': 'mandek',
'kemandekannya': 'mandek',
'memandekkan': 'mandek',
'bermandi': 'mandi',
'bermandikan': 'mandi',
'bermandian': 'mandi',
'pemandian': 'mandi',
'pemandiannya': 'mandi',
'memandikan': 'mandi',
'memandikannya': 'mandi',
'memandikanku': 'mandi',
'permandian': 'mandi',
'mempermandikan': 'mandi',
'kemandirian': 'mandiri',
'kemandiriannya': 'mandiri',
'kemandirianmu': 'mandiri',
'memandori': 'mandor',
'kemandulan': 'mandul',
'kemandulannya': 'mandul',
'pemandulan': 'mandul',
'pemandulannya': 'mandul',
'memandulkan': 'mandul',
'memandulkannya': 'mandul',
'termangau': 'mangau',
'pemangkir': 'mangkir',
'pemangkiran': 'mangkir',
'semangkuk': 'mangkuk',
'memangsa': 'mangsa',
'memangsanya': 'mangsa',
'pemangsa': 'mangsa',
'pemangsanya': 'mangsa',
'pemangsaan': 'mangsa',
'termangu': 'mangu',
'termangu-mangu': 'mangu',
'termanifestasi': 'manifestasi',
'termanifestasikan': 'manifestasi',
'memanifestasikan': 'manifestasi',
'memanifestasikannya': 'manifestasi',
'manik-manik': 'manik',
'manik-maniknya': 'manik',
'bermanik-manik': 'manik',
'memanipulasi': 'manipulasi',
'memanipulasinya': 'manipulasi',
'memanipulasikan': 'manipulasi',
'memanipulasiku': 'manipulasi',
'pemanipulasian': 'manipulasi',
'memanis': 'manis',
'memaniskan': 'manis',
'semanis': 'manis',
'manisan': 'manis',
'manisannya': 'manis',
'pemanis': 'manis',
'pemanisnya': 'manis',
'bermanis': 'manis',
'memanisi': 'manis',
'kemanisan': 'manis',
'kemanisannya': 'manis',
'mempermanis': 'manis',
'mempermanisnya': 'manis',
'manis-manisan': 'manis',
'memanis-manis': 'manis',
'memanis-maniskan': 'manis',
'bermanis-manis': 'manis',
'semanis-manisnya': 'manis',
'kemanjaan': 'manja',
'kemanjaannya': 'manja',
'memanjakan': 'manja',
'memanjakannya': 'manja',
'memanjakanan': 'manja',
'memanjakanku': 'manja',
'memanjakanmu': 'manja',
'bermanja-manja': 'manja',
'bermanja-manjaan': 'manja',
'termanja-manja': 'manja',
'mempermanjakan': 'manja',
'kemanja-manjaan': 'manja',
'bermanjau': 'manjau',
'manjungan': 'manjung',
'permanjungan': 'manjung',
'memansukhkan': 'mansukh',
'pemantapan': 'mantap',
'pemantapannya': 'mantap',
'kemantapan': 'mantap',
'kemantapannya': 'mantap',
'memantapkan': 'mantap',
'memantapkannya': 'mantap',
'bermantel': 'mantel',
'memantrai': 'mantra',
'memantrakan': 'mantra',
'kemanunggalan': 'manunggal',
'memanusiawikan': 'manusiawi',
'manutan': 'manut',
'bermanuver': 'manuver',
'bermanuvernya': 'manuver',
'bermanuverlah': 'manuver',
'kemapanan': 'mapan',
'kemapanannya': 'mapan',
'bermara': 'mara',
'kemaraan': 'mara',
'memarakan': 'marak',
'pemarah': 'marah',
'pemarahnya': 'marah',
'pemarahku': 'marah',
'marahan': 'marah',
'memarahi': 'marah',
'memarahinya': 'marah',
'memarahiku': 'marah',
'kemarahan': 'marah',
'kemarahannya': 'marah',
'kemarahanan': 'marah',
'kemarahanku': 'marah',
'kemarahanmu': 'marah',
'memarahkan': 'marah',
'marah-marah': 'marah',
'marah-marahnya': 'marah',
'marah-marahlah': 'marah',
'marah-marahi': 'marah',
'marah-marahan': 'marah',
'kemarah-marahan': 'marah',
'memarak': 'marak',
'memarakkan': 'parak',
'semarak': 'marak',
'semaraknya': 'marak',
'semarakkan': 'marak',
'semarakan': 'marak',
'memarginalkan': 'marginal',
'memarinade': 'marinade',
'kemaritiman': 'maritim',
'kemaritimannya': 'maritim',
'kemaritimanan': 'maritim',
'pemarkah': 'markah',
'memarkahi': 'markah',
'pemarkahan': 'markah',
'bermarkas': 'markas',
'bermarkasnya': 'markas',
'bermarkaskan': 'markas',
'bermarkasi': 'markas',
'bermartabat': 'martabat',
'bermartabatnya': 'martabat',
'bermartabatlah': 'martabat',
'kemasabodohan': 'masa bodoh',
'memasabodohkan': 'masa bodoh',
'semasa': 'masa',
'semasanya': 'masa',
'termasa': 'masa',
'semasa-masa': 'masa',
'memasak': 'pasak',
'memasaknya': 'pasak',
'memasaklah': 'pasak',
'memasakkan': 'pasak',
'memasakkannya': 'pasak',
'memasaki': 'pasak',
'memasakan': 'pasak',
'memasakku': 'pasak',
'memasakmu': 'pasak',
'masakan': 'masak',
'masakannya': 'masak',
'masakanan': 'masak',
'masakanku': 'masak',
'masakanmu': 'masak',
'pemasak': 'masak',
'pemasaknya': 'masak',
'pemasakan': 'masak',
'pemasakannya': 'masak',
'kemasakan': 'masak',
'kemasakannya': 'masak',
'masak-masak': 'masak',
'masak-masaknya': 'masak',
'masak-masakan': 'masak',
'memasak-masak': 'masak',
'bermasak-masak': 'masak',
'memasalahkan': 'masalah',
'memasalahkannya': 'masalah',
'permasalahan': 'masalah',
'permasalahannya': 'masalah',
'permasalahanku': 'masalah',
'mempermasalahkan': 'masalah',
'mempermasalahkannya': 'masalah',
'memasam': 'masam',
'memasamkan': 'masam',
'kemasam-masaman': 'masam',
'bermasam muka': 'masam muka',
'memasap': 'masap',
'memaserasi': 'maserasi',
'semasih': 'masih',
'kemasinan': 'masin',
'permasjidan': 'masjid',
'memaskotkan': 'maskot',
'kemaslahatan': 'maslahat',
'kemaslahatannya': 'maslahat',
'memasyarakat': 'masyarakat',
'memasyarakatnya': 'masyarakat',
'memasyarakatkan': 'masyarakat',
'memasyarakatkannya': 'masyarakat',
'memasyarakatan': 'masyarakat',
'bermasyarakat': 'masyarakat',
'bermasyarakatnya': 'masyarakat',
'pemasyarakatan': 'masyarakat',
'pemasyarakatannya': 'masyarakat',
'kemasyarakatan': 'masyarakat',
'kemasyarakatannya': 'masyarakat',
'kemasyarakatanlah': 'masyarakat',
'permasyarakatan': 'masyarakat',
'permasyarakatannya': 'masyarakat',
'kemasygulan': 'masygul',
'memasygulkan': 'masygul',
'mat-matan': 'mat',
'memata-matai': 'mata-mata',
'memata-matainya': 'mata-mata',
'pemata-mataan': 'mata-mata',
'termateri': 'materi',
'semati': 'mati',
'kematian': 'mati',
'kematiannya': 'mati',
'kematianku': 'mati',
'kematianmu': 'mati',
'bermatian': 'mati',
'mematikan': 'patik',
'mematikannya': 'mati',
'mati-mati': 'mati',
'mati-matian': 'mati',
'bermatikan': 'mati',
'mati-matianlah': 'mati',
'bermati-mati': 'mati',
'kemati-matian': 'mati',
'kematraan': 'matra',
'mematukan': 'matu',
'semau': 'mau',
'semaunya': 'mau',
'semaumu': 'mau',
'memaui': 'mau',
'maupun': 'mau',
'maupunnya': 'mau',
'kemauan': 'mau',
'kemauannya': 'mau',
'kemauanlah': 'mau',
'kemauanan': 'mau',
'kemauanku': 'mau',
'kemauanmu': 'mau',
'memaukan': 'mau',
'memau-mau': 'mau',
'semau-maunya': 'mau',
'maupun': 'mau',
'bermaulid': 'maulid',
'bermaulidurasul': 'maulidurasul',
'mauludan': 'maulud',
'permautan': 'maut',
'kemayaan': 'maya',
'maya-maya': 'maya',
'pemayang': 'mayang',
'semayang': 'mayang',
'bermayang': 'mayang',
'bermazhab': 'mazhab',
'termazkur': 'mazkur',
'bermazmur': 'mazmur',
'bermeditasi': 'meditasi',
'bermeditasilah': 'meditasi',
'meger-meger': 'meger',
'dimejahijaukan': 'meja hijau',
'dimejahijaukannya': 'meja hijau',
'pemekaran': 'mekar',
'pemekarannya': 'mekar',
'bermekaran': 'mekar',
'bermekarannya': 'mekar',
'memekarkan': 'mekar',
'memelas': 'pelas',
'memelasnya': 'pelas',
'melek-melekan': 'melek',
'kemelikan': 'melik',
'memacak': 'pacak',
'terpacak': 'pacak',
'memacakkan': 'pacak',
'memacak-macak': 'pacak',
'memagar': 'pagar',
'memagarnya': 'pagar',
'memagarkan': 'pagar',
'memagari': 'pagar',
'berpagar': 'pagar',
'berpagarkan': 'pagar',
'memagarinya': 'pagar',
'pagutan': 'pagut',
'pagutannya': 'pagut',
'memagut': 'pagut',
'berpagut': 'pagut',
'berpagutan': 'pagut',
'sepemagutan': 'pagut',
'pakaian': 'pakai',
'pakaiannya': 'pakai',
'pakaianlah': 'pakai',
'pakaianku': 'pakai',
'pakaianmu': 'pakai',
'memakai': 'pakai',
'memakainya': 'pakai',
'memakaikan': 'pakai',
'memakaikannya': 'pakai',
'memakaian': 'pakai',
'pemakai': 'pakai',
'pemakainya': 'pakai',
'pemakaikan': 'pakai',
'pemakaian': 'pakai',
'terpakai': 'pakai',
'terpakainya': 'pakai',
'sepemakai': 'pakai',
'pemakaiannya': 'pakai',
'memakaikanku': 'pakai',
'berpakaian': 'pakai',
'berpakaiannya': 'pakai',
'berpakaianlah': 'pakai',
'berpakaianan': 'pakai',
'berpakaianmu': 'pakai',
'pemakal': 'pakal',
'memakal': 'pakal',
'memaku': 'paku',
'memakunya': 'paku',
'memakukan': 'paku',
'berpaku': 'paku',
'terpaku': 'paku',
'terpakunya': 'paku',
'keterpakuan': 'paku',
'memampang': 'pampang',
'memampangnya': 'pampang',
'memampangkan': 'pampang',
'memampangkannya': 'pampang',
'terpampang': 'pampang',
'terpampangnya': 'pampang',
'terpampanglah': 'pampang',
'pemanah': 'panah',
'pemanahnya': 'panah',
'pemanahan': 'panah',
'memanah': 'panah',
'memanahnya': 'panah',
'memanahkan': 'panah',
'panahan': 'panah',
'panahannya': 'panah',
'panahanan': 'panah',
'memanahi': 'panah',
'sepemanah': 'panah',
'pancangan': 'pancang',
'memancang': 'pancang',
'memancangnya': 'pancang',
'memancangkan': 'pancang',
'terpancang': 'pancang',
'pemancar': 'pancar',
'pemancarnya': 'pancar',
'pemancaran': 'pancar',
'sepancar': 'pancar',
'pancaran': 'pancar',
'pancarannya': 'pancar',
'memancar': 'pancar',
'memancarnya': 'pancar',
'memancarkan': 'pancar',
'memancarkannya': 'pancar',
'memancaran': 'pancar',
'terpancar': 'pancar',
'terpancarnya': 'pancar',
'terpancarkan': 'pancar',
'berpancaran': 'pancar',
'pancingan': 'pancing',
'pancingannya': 'pancing',
'memancing': 'pancing',
'memancingnya': 'pancing',
'memancinglah': 'pancing',
'memancingan': 'pancing',
'pemancing': 'pancing',
'pemancingan': 'pancing',
'terpancing': 'pancing',
'terpancinglah': 'pancing',
'kepancingan': 'pancing',
'pemancingannya': 'pancing',
'memancung': 'pancung',
'memancungnya': 'pancung',
'memancungkan': 'pancung',
'pemancung': 'pancung',
'pemancungan': 'pancung',
'memancur': 'pancur',
'memancurkan': 'pancur',
'pancuran': 'pancur',
'pancurannya': 'pancur',
'berpancuran': 'pancur',
'memancut': 'pancut',
'sememangnya': 'memang',
'pemanggil': 'panggil',
'pemanggilan': 'panggil',
'panggilan': 'panggil',
'panggilannya': 'panggil',
'panggilanku': 'panggil',
'panggilanmu': 'panggil',
'memanggil': 'panggil',
'memanggilnya': 'panggil',
'memanggilkan': 'panggil',
'memanggilkannya': 'panggil',
'memanggili': 'panggil',
'memanggilan': 'panggil',
'memanggilku': 'panggil',
'memanggilmu': 'panggil',
'terpanggil': 'panggil',
'terpanggilnya': 'panggil',
'pemanggilannya': 'panggil',
'sepemanggil': 'panggil',
'memanggil-manggil': 'panggil',
'memanggil-manggilnya': 'panggil',
'memanggil-manggilku': 'panggil',
'memangkas': 'pangkas',
'memangkasnya': 'pangkas',
'memangkaskan': 'pangkas',
'memangkasi': 'pangkas',
'memangkasan': 'pangkas',
'pemangkas': 'pangkas',
'pemangkasan': 'pangkas',
'pangkasan': 'pangkas',
'berpangkas': 'pangkas',
'pemangkasannya': 'pangkas',
'memantak': 'pantak',
'memantakkan': 'pantak',
'pantangan': 'pantang',
'pantangannya': 'pantang',
'pantanganku': 'pantang',
'pantanganmu': 'pantang',
'memantang': 'pantang',
'memantangkan': 'pantang',
'memantangi': 'pantang',
'berpantang': 'pantang',
'berpantangan': 'pantang',
'pantulan': 'pantul',
'pantulannya': 'pantul',
'memantul': 'pantul',
'memantulnya': 'pantul',
'memantulkan': 'pantul',
'memantulkannya': 'pantul',
'pemantulan': 'pantul',
'memantulkanku': 'pantul',
'memapar': 'papar',
'memaparkan': 'papar',
'memaparkannya': 'papar',
'memaparan': 'papar',
'paparan': 'papar',
'paparannya': 'papar',
'pemaparan': 'papar',
'pemaparannya': 'papar',
'pemaparankan': 'papar',
'berparak': 'parak',
'terpasak': 'pasak',
'pasangan': 'pasang',
'pasangannya': 'pasang',
'pasanganlah': 'pasang',
'pasanganan': 'pasang',
'pasangannyalah': 'pasang',
'pasanganku': 'pasang',
'pasanganmu': 'pasang',
'pemasang': 'pasang',
'pemasangnya': 'pasang',
'pemasangan': 'pasang',
'memasang': 'pasang',
'memasangnya': 'pasang',
'memasangkan': 'pasang',
'memasangkannya': 'pasang',
'memasangi': 'pasang',
'memasangan': 'pasang',
'sepasang': 'pasang',
'sepasangnya': 'pasang',
'sepasangan': 'pasang',
'berpasang': 'pasang',
'berpasangkan': 'pasang',
'berpasangan': 'pasang',
'terpasang': 'pasang',
'terpasangnya': 'pasang',
'terpasanglah': 'pasang',
'terpasangkan': 'pasang',
'terpasangi': 'pasang',
'terpasangan': 'pasang',
'pemasangannya': 'pasang',
'pasang-memasang': 'pasang',
'berpasang-pasang': 'pasang',
'berpasang-pasangan': 'pasang',
'pemasar': 'pasar',
'pemasarnya': 'pasar',
'pemasarkan': 'pasar',
'pemasaran': 'pasar',
'pasaran': 'pasar',
'pasarannya': 'pasar',
'pasaranan': 'pasar',
'pemasarannya': 'pasar',
'memasarkan': 'pasar',
'memasarkannya': 'pasar',
'pematah': 'patah',
'pematahan': 'patah',
'patahan': 'patah',
'patahannya': 'patah',
'mematahkan': 'patah',
'mematahkannya': 'patah',
'mematahkankan': 'patah',
'mematahkanmu': 'patah',
'mematah-matah': 'patah',
'mematuk': 'patuk',
'mematuknya': 'patuk',
'mematukkan': 'patuk',
'mematuki': 'patuk',
'mematukku': 'patuk',
'mematuk-matuk': 'patuk',
'berangsangan': 'berangsang',
'pemberangsang': 'berangsang',
'memberangsang': 'berangsang',
'memberangsangkan': 'berangsang',
'memecah belah': 'pecah belah',
'pemecah belah': 'pecah belah',
'berpecah belah': 'pecah belah',
'memecahbelahkan': 'pecah belah',
'memecah': 'pecah',
'memecahnya': 'pecah',
'memecahkan': 'pecah',
'memecahkannya': 'pecah',
'memecahi': 'pecah',
'memecahan': 'pecah',
'pemecah': 'pecah',
'pemecahan': 'pecah',
'pecahan': 'pecah',
'pecahannya': 'pecah',
'pecahanan': 'pecah',
'berpecah': 'pecah',
'berpecahan': 'pecah',
'terpecah': 'pecah',
'terpecahnya': 'pecah',
'terpecahlah': 'pecah',
'terpecahkan': 'pecah',
'terpecahkannya': 'pecah',
'pemecahannya': 'pecah',
'pemecahanan': 'pecah',
'pemecahanku': 'pecah',
'kepecahan': 'pecah',
'kepecahannya': 'pecah',
'memecahkankan': 'pecah',
'perpecahan': 'pecah',
'perpecahannya': 'pecah',
'perpecahanan': 'pecah',
'terpecah-pecah': 'pecah',
'terpecah-pecahnya': 'pecah',
'memecat': 'pecat',
'memecatnya': 'pecat',
'memecati': 'pecat',
'memecatku': 'pecat',
'memecatmu': 'pecat',
'pemecatan': 'pecat',
'pemecatannya': 'pecat',
'pemecatanku': 'pecat',
'pemecatanmu': 'pecat',
'memecatkan': 'pecat',
'memecut': 'pecut',
'memecutnya': 'pecut',
'memecutkan': 'pecut',
'pemegang': 'pegang',
'pemegangnya': 'pegang',
'pemegangan': 'pegang',
'pegangan': 'pegang',
'pegangannya': 'pegang',
'peganganan': 'pegang',
'peganganku': 'pegang',
'memegang': 'pegang',
'memegangnya': 'pegang',
'memegangkan': 'pegang',
'memegangi': 'pegang',
'memegangan': 'pegang',
'memegangmu': 'pegang',
'perpegangan': 'pegang',
'berpegangan': 'pegang',
'berpegang': 'pegang',
'bermemek-memek': 'memek',
'terpekak': 'pekak',
'memekakkan': 'pekak',
'pekak-pekak': 'pekak',
'memekik': 'pekik',
'memekiknya': 'pekik',
'memekikkan': 'pekik',
'memekikan': 'pekik',
'pekikan': 'pekik',
'pekikannya': 'pekik',
'terpekik': 'pekik',
'pekik-pekuk': 'pekik',
'terpekik-pekik': 'pekik',
'memencar': 'pencar',
'memencarkan': 'pencar',
'memencari': 'pencar',
'berpencar': 'pencar',
'berpencarnya': 'pencar',
'berpencaran': 'pencar',
'terpencar': 'pencar',
'terpencarnya': 'pencar',
'terpencarkan': 'pencar',
'pemencaran': 'pencar',
'memencar-mencar': 'pencar',
'terpencar-pencar': 'pencar',
'terpencar-pencari': 'pencar',
'berpencar-pencar': 'pencar',
'memencil': 'pencil',
'memencilkan': 'pencil',
'terpencil': 'pencil',
'terpencilnya': 'pencil',
'pemencilan': 'pencil',
'keterpencilan': 'pencil',
'keterpencilannya': 'pencil',
'memendam': 'pendam',
'memendamnya': 'pendam',
'terpendam': 'pendam',
'terpendamnya': 'pendam',
'terpendamkan': 'pendam',
'memendamkan': 'pendam',
'sepenggal': 'penggal',
'sepenggalan': 'penggal',
'penggalan': 'penggal',
'penggalannya': 'penggal',
'penggalanan': 'penggal',
'memenggal': 'penggal',
'memenggalnya': 'penggal',
'memenggalku': 'penggal',
'pemenggal': 'penggal',
'pemenggalan': 'penggal',
'terpenggal': 'penggal',
'terpenggalnya': 'penggal',
'pemenggalannya': 'penggal',
'berpenggalan': 'penggal',
'berpenggal-penggal': 'penggal',
'kepeningan': 'pening',
'memeningkan': 'pening',
'memenjara': 'penjara',
'memenjarakan': 'penjara',
'memenjarakannya': 'penjara',
'terpenjara': 'penjara',
'terpenjarakan': 'penjara',
'kepenjaraan': 'penjara',
'memenjarakanku': 'penjara',
'sepenuh': 'penuh',
'sepenuhnya': 'penuh',
'sepenuhkan': 'penuh',
'sepenuhi': 'penuh',
'sepenuhnyalah': 'penuh',
'memenuhi': 'penuh',
'memenuhinya': 'penuh',
'memenuhii': 'penuh',
'pemenuhan': 'penuh',
'pemenuhannya': 'penuh',
'pemenuhanan': 'penuh',
'terpenuhi': 'penuh',
'terpenuhinya': 'penuh',
'terpenuhilah': 'penuh',
'terpenuhikan': 'penuh',
'perahan': 'perah',
'perahannya': 'perah',
'perahanan': 'perah',
'pemerah': 'perah',
'pemerahan': 'perah',
'memerah': 'perah',
'memerahnya': 'perah',
'memerahkan': 'perah',
'memerahi': 'perah',
'pemerahannya': 'perah',
'kemerahan': 'merah',
'kemerahannya': 'merah',
'kemerah-merahan': 'merah',
'pemeram': 'peram',
'pemeraman': 'peram',
'peraman': 'peram',
'memeram': 'peram',
'memerami': 'peram',
'berperam': 'peram',
'memerangkap': 'perangkap',
'memerangkapnya': 'perangkap',
'memerangkapkan': 'perangkap',
'terperangkap': 'perangkap',
'terperangkapnya': 'perangkap',
'terperanjat': 'peranjat',
'memeranjatkan': 'peranjat',
'memeras': 'peras',
'memerasnya': 'peras',
'memeraskannya': 'peras',
'memerasan': 'peras',
'memerasku': 'peras',
'pemeras': 'peras',
'pemerasnya': 'peras',
'pemerasan': 'peras',
'perasan': 'peras',
'perasannya': 'peras',
'perasanku': 'peras',
'pemerasannya': 'peras',
'tepercik': 'percik',
'percikan': 'percik',
'percikannya': 'percik',
'memercik': 'percik',
'memercikkan': 'percik',
'memercikkannya': 'percik',
'memerciki': 'percik',
'memercikan': 'percik',
'bepercikan': 'percik',
'memercik-mercik': 'percik',
'memercik-mercikkan': 'percik',
'pemerhati': 'perhati',
'pemerhatian': 'perhati',
'perhatian': 'perhati',
'perhatiannya': 'perhati',
'perhatianlah': 'perhati',
'perhatianku': 'perhati',
'perhatianmu': 'perhati',
'memerhatikan': 'perhati',
'memerhatikannya': 'perhati',
'memerhatikanku': 'perhati',
'berperhatian': 'perhati',
'keperihan': 'perih',
'memerihkan': 'perih',
'periksaan': 'periksa',
'memeriksa': 'periksa',
'memeriksanya': 'periksa',
'memeriksakan': 'periksa',
'memeriksakannya': 'periksa',
'memeriksai': 'periksa',
'memeriksaan': 'periksa',
'memeriksaku': 'periksa',
'pemeriksa': 'periksa',
'pemeriksanya': 'periksa',
'pemeriksakan': 'periksa',
'pemeriksaan': 'periksa',
'terperiksa': 'periksa',
'terperiksanya': 'periksa',
'pemeriksaannya': 'periksa',
'pemeriksaanlah': 'periksa',
'pemeriksaani': 'periksa',
'pemeriksaanan': 'periksa',
'memesat': 'pesat',
'memesatkan': 'pesat',
'kepesatan': 'pesat',
'memesong': 'pesong',
'pemesong': 'pesong',
'terpesong': 'pesong',
'memesongkan': 'pesong',
'memesukkan': 'pesuk',
'berpesuk-pesuk': 'pesuk',
'memetik': 'petik',
'memetiknya': 'petik',
'memetikkan': 'petik',
'memetiki': 'petik',
'memetikan': 'petik',
'petikan': 'petik',
'petikannya': 'petik',
'petikanan': 'petik',
'pemetik': 'petik',
'pemetiknya': 'petik',
'pemetikan': 'petik',
'terpetik': 'petik',
'terpetiklah': 'petik',
'pemetikannya': 'petik',
'picitan': 'picit',
'memicit': 'picit',
'terpicit': 'picit',
'memihak': 'pihak',
'memihaknya': 'pihak',
'memihakmu': 'pihak',
'sepihak': 'pihak',
'sepihaknya': 'pihak',
'memihaki': 'pihak',
'berpihak': 'pihak',
'berpihaknya': 'pihak',
'berpihaklah': 'pihak',
'berpihakan': 'pihak',
'pemihakan': 'pihak',
'pemihakannya': 'pihak',
'memihakkan': 'pihak',
'keberpihakan': 'pihak',
'keberpihakannya': 'pihak',
'keberpihakanlah': 'pihak',
'keberpihakanmu': 'pihak',
'berpihak-pihak': 'pihak',
'pemikat': 'pikat',
'pemikatnya': 'pikat',
'pemikatan': 'pikat',
'memikat': 'pikat',
'memikatnya': 'pikat',
'memikatku': 'pikat',
'pikatan': 'pikat',
'terpikat': 'pikat',
'terpikatnya': 'pikat',
'keterpikatan': 'pikat',
'memilih': 'pilih',
'memilihnya': 'pilih',
'memilihlah': 'pilih',
'memilihkan': 'pilih',
'memilihkannya': 'pilih',
'memilihi': 'pilih',
'memilihan': 'pilih',
'memilihku': 'pilih',
'memilihmu': 'pilih',
'pilihan': 'pilih',
'pilihannya': 'pilih',
'pilihanlah': 'pilih',
'pilihanan': 'pilih',
'pilihanku': 'pilih',
'pilihanmu': 'pilih',
'pemilih': 'pilih',
'pemilihnya': 'pilih',
'pemilihlah': 'pilih',
'pemilihkan': 'pilih',
'pemilihan': 'pilih',
'pemilihmu': 'pilih',
'terpilih': 'pilih',
'terpilihnya': 'pilih',
'terpilihlah': 'pilih',
'terpilihkan': 'pilih',
'terpilihan': 'pilih',
'pemilihannya': 'pilih',
'pemilihanan': 'pilih',
'pemilihanku': 'pilih',
'pilih-pilih': 'pilih',
'pilih-pilihnya': 'pilih',
'pilih-pilihlah': 'pilih',
'pilih-pilihan': 'pilih',
'memilih-milih': 'pilih',
'berpilih-pilih': 'pilih',
'pemilik': 'milik',
'pemiliknya': 'milik',
'pemiliklah': 'milik',
'pemiliki': 'milik',
'pemilikan': 'milik',
'pemiliknyalah': 'milik',
'pemilikku': 'milik',
'termilik': 'milik',
'termiliki': 'milik',
'memiliki': 'milik',
'memilikinya': 'milik',
'memilikii': 'milik',
'memilikiku': 'milik',
'memilikimu': 'milik',
'memiliki-mu': 'milik',
'pemilikannya': 'milik',
'kemilikan': 'milik',
'kepemilikan': 'milik',
'kepemilikannya': 'milik',
'kepemilikanku': 'milik',
'memilin': 'pilin',
'memilinnya': 'pilin',
'pilinan': 'pilin',
'pilinannya': 'pilin',
'berpilin': 'pilin',
'pemilinan': 'pilin',
'pilin-memilin': 'pilin',
'memilin-milin': 'pilin',
'berpilin-pilin': 'pilin',
'meminang': 'pinang',
'meminangnya': 'pinang',
'meminangkan': 'pinang',
'meminangku': 'pinang',
'peminang': 'pinang',
'peminangnya': 'pinang',
'peminangan': 'pinang',
'pinangan': 'pinang',
'pinangannya': 'pinang',
'pinanganku': 'pinang',
'meminang-minang': 'pinang',
'pinjaman': 'pinjam',
'pinjamannya': 'pinjam',
'pinjamanan': 'pinjam',
'pinjamanku': 'pinjam',
'pinjamanmu': 'pinjam',
'meminjam': 'pinjam',
'meminjamnya': 'pinjam',
'meminjamkan': 'pinjam',
'meminjamkannya': 'pinjam',
'meminjami': 'pinjam',
'meminjaman': 'pinjam',
'meminjamku': 'pinjam',
'peminjam': 'pinjam',
'peminjamnya': 'pinjam',
'peminjamkan': 'pinjam',
'peminjaman': 'pinjam',
'meminjaminya': 'pinjam',
'meminjamimu': 'pinjam',
'peminjamannya': 'pinjam',
'peminjamanku': 'pinjam',
'meminjamkankan': 'pinjam',
'meminjamkanku': 'pinjam',
'pinjam-meminjam': 'pinjam',
'memintas': 'pintas',
'memintasi': 'pintas',
'pintasan': 'pintas',
'sepintas': 'pintas',
'sepintasnya': 'pintas',
'pemintasan': 'pintas',
'kepintasan': 'pintas',
'memintaskan': 'pintas',
'meminum': 'minum',
'meminumnya': 'minum',
'meminumkan': 'minum',
'meminumkannya': 'minum',
'meminuman': 'minum',
'minuman': 'minum',
'minumannya': 'minum',
'minumanlah': 'minum',
'minumanan': 'minum',
'minumanku': 'minum',
'minumanmu': 'minum',
'peminum': 'minum',
'peminumnya': 'minum',
'peminuman': 'minum',
'meminumi': 'minum',
'terminum': 'minum',
'memisit': 'pisit',
'memohon': 'pohon',
'memohonnya': 'pohon',
'memohonkan': 'pohon',
'memohonan': 'pohon',
'pepohonan': 'pohon',
'pepohonannya': 'pohon',
'pohon-pohonan': 'pohon',
'memonopoli': 'monopoli',
'memonopolinya': 'monopoli',
'memotivasi': 'motivasi',
'memotivasinya': 'motivasi',
'memotivasiku': 'motivasi',
'memotivasimu': 'motivasi',
'memotivasi-mu': 'motivasi',
'termotivasi': 'motivasi',
'termotivasinya': 'motivasi',
'potongan': 'potong',
'potongannya': 'potong',
'pemotong': 'potong',
'pemotongnya': 'potong',
'pemotongan': 'potong',
'memotong': 'potong',
'memotongnya': 'potong',
'memotongkan': 'potong',
'memotongi': 'potong',
'memotongan': 'potong',
'berpotong': 'potong',
'berpotongan': 'potong',
'terpotong': 'potong',
'terpotongnya': 'potong',
'terpotonglah': 'potong',
'pemotongannya': 'potong',
'perpotongan': 'potong',
'perpotongannya': 'potong',
'potong-memotong': 'potong',
'memperpotongkan': 'potong',
'memotong-motong': 'potong',
'memotong-motongnya': 'potong',
'berpotong-potong': 'potong',
'berpotong-potongan': 'potong',
'memotret': 'potret',
'memotretnya': 'potret',
'memotretlah': 'potret',
'memotretku': 'potret',
'pemotret': 'potret',
'pemotretnya': 'potret',
'pemotretan': 'potret',
'berpotret': 'potret',
'pemotretannya': 'potret',
'memparafrasakan': 'parafrasa',
'beroleh': 'oleh',
'berolehkan': 'oleh',
'perolehan': 'oleh',
'perolehannya': 'oleh',
'memperoleh': 'oleh',
'memperolehnya': 'oleh',
'memperolehkan': 'oleh',
'memperolehkannya': 'oleh',
'memperolehan': 'oleh',
'pemerolehan': 'oleh',
'sembahan': 'sembah',
'penyembah': 'sembah',
'penyembahnya': 'sembah',
'penyembahan': 'sembah',
'menyembah': 'sembah',
'menyembahnya': 'sembah',
'menyembahkan': 'sembah',
'menyembah-ku': 'sembah',
'bersembah': 'sembah',
'bersembahan': 'sembah',
'persembahan': 'sembah',
'persembahannya': 'sembah',
'mempersembahkan': 'sembah',
'mempersembahkannya': 'sembah',
'senda gurau': 'senda',
'mempersendakan': 'senda',
'bersenda-senda': 'senda',
'bersenda gurau': 'senda',
'silakan': 'sila',
'silakanlah': 'sila',
'tersila': 'sila',
'silalah': 'sila',
'silalahi': 'sila',
'bersila': 'sila',
'menyilakan': 'sila',
'menyilakannya': 'sila',
'mempersilakan': 'sila',
'mempersilakannya': 'sila',
'mempersilakanku': 'sila',
'petunang': 'tunang',
'petunangan': 'tunang',
'tunangan': 'tunang',
'tunangannya': 'tunang',
'tunanganlah': 'tunang',
'tunanganku': 'tunang',
'menunangi': 'tunang',
'menunangkan': 'tunang',
'bertunangan': 'tunang',
'bertunanganlah': 'tunang',
'pertunangan': 'tunang',
'pertunangannya': 'tunang',
'pertunanganmu': 'tunang',
'mempertunangkan': 'tunang',
'menunjuk': 'tunjuk',
'menunjuknya': 'tunjuk',
'menunjukkan': 'tunjuk',
'menunjukkannya': 'tunjuk',
'menunjuki': 'tunjuk',
'menunjukan': 'tunjuk',
'menunjukku': 'tunjuk',
'petunjuk': 'tunjuk',
'petunjuknya': 'tunjuk',
'petunjukkan': 'tunjuk',
'petunjukan': 'tunjuk',
'petunjuk-mu': 'tunjuk',
'penunjuk': 'tunjuk',
'penunjuknya': 'tunjuk',
'penunjukkan': 'tunjuk',
'penunjukkannya': 'tunjuk',
'penunjukan': 'tunjuk',
'menunjukikan': 'tunjuk',
'pertunjuk': 'tunjuk',
'pertunjukkan': 'tunjuk',
'pertunjukkannya': 'tunjuk',
'pertunjukan': 'tunjuk',
'penunjukannya': 'tunjuk',
'penunjukanku': 'tunjuk',
'menunjukkanlah': 'tunjuk',
'menunjukkankan': 'tunjuk',
'menunjukkani': 'tunjuk',
'menunjukkanku': 'tunjuk',
'pertunjukannya': 'tunjuk',
'tunjuk-menunjuk': 'tunjuk',
'mempertunjukkan': 'tunjuk',
'mempertunjukkannya': 'tunjuk',
'bertunjuk-tunjukan': 'tunjuk',
'memproklamasikan': 'proklamasi',
'memproklamasikankan': 'proklamasi',
'mempromosikan': 'promosi',
'mempromosikannya': 'promosi',
'mempromosikani': 'promosi',
'pemropaganda': 'propaganda',
'berpropaganda': 'propaganda',
'mempropagandakan': 'propaganda',
'mempropagandakannya': 'propaganda',
'pemroses': 'proses',
'pemrosesnya': 'proses',
'pemrosesan': 'proses',
'memproses': 'proses',
'memprosesnya': 'proses',
'memprosesi': 'proses',
'memprosesan': 'proses',
'berproses': 'proses',
'berprosesnya': 'proses',
'berproseslah': 'proses',
'berproseskan': 'proses',
'berprosesi': 'proses',
'pemrosesannya': 'proses',
'berpunya': 'punya',
'mempunyai': 'punya',
'mempunyainya': 'punya',
'mempunyaii': 'punya',
'kepunyaan': 'punya',
'kepunyaannya': 'punya',
'kepunyaanku': 'punya',
'kepunyaanmu': 'punya',
'mempunyakan': 'punya',
'memuakkan': 'muak',
'memualkan': 'mual',
'pemuasan': 'puas',
'kepuasan': 'puas',
'kepuasannya': 'puas',
'memuaskan': 'puas',
'memuaskannya': 'puas',
'memuaskanlah': 'puas',
'memuaskankan': 'puas',
'memuaskanku': 'puas',
'memuaskanmu': 'puas',
'berpuas diri': 'puas',
'sepuas-puasnya': 'puas',
'memuat': 'muat',
'memuatnya': 'muat',
'memuatkan': 'muat',
'memuati': 'muat',
'memuatan': 'muat',
'pemuat': 'muat',
'pemuatan': 'muat',
'muatan': 'muat',
'muatannya': 'muat',
'termuat': 'muat',
'termuatnya': 'muat',
'pemuatannya': 'muat',
'bermuatan': 'muat',
'memudar': 'pudar',
'memudarnya': 'pudar',
'memudarkan': 'pudar',
'pemudaran': 'pudar',
'pemuja': 'puja',
'pemujanya': 'puja',
'pemujaan': 'puja',
'memuja': 'puja',
'memujanya': 'puja',
'memujaku': 'puja',
'memujamu': 'puja',
'pujaan': 'puja',
'pujaannya': 'puja',
'pujaanku': 'puja',
'pemujaannya': 'puja',
'memuja-muja': 'puja',
'memuja-mujanya': 'puja',
'pemukat': 'pukat',
'pemukatan': 'pukat',
'memukat': 'pukat',
'memukau': 'pukau',
'memukaunya': 'pukau',
'pukauan': 'pukau',
'terpukau': 'pukau',
'terpukaunya': 'pukau',
'pukulan': 'pukul',
'pukulannya': 'pukul',
'pukulanlah': 'pukul',
'pukulanmu': 'pukul',
'memukul': 'pukul',
'memukulnya': 'pukul',
'memukulkan': 'pukul',
'memukulkannya': 'pukul',
'memukuli': 'pukul',
'memukulku': 'pukul',
'memukulmu': 'pukul',
'pemukul': 'pukul',
'pemukulnya': 'pukul',
'pemukulan': 'pukul',
'memukulinya': 'pukul',
'memukuliku': 'pukul',
'memukulimu': 'pukul',
'terpukul': 'pukul',
'terpukulnya': 'pukul',
'pemukulannya': 'pukul',
'memperpukuli': 'pukul',
'pukul-memukul': 'pukul',
'memperpukulkan': 'pukul',
'pemukulrataan': 'pukul rata',
'memukulratakan': 'pukul rata',
'memulas': 'pulas',
'memulasnya': 'pulas',
'memulaskan': 'pulas',
'memulaskannya': 'pulas',
'memulasi': 'pulas',
'pulasan': 'pulas',
'pulasannya': 'pulas',
'kepulasan': 'pulas',
'berpulasan': 'pulas',
'pemulihan': 'pulih',
'pemulihannya': 'pulih',
'pemulihanku': 'pulih',
'pemulihanmu': 'pulih',
'memulihkan': 'pulih',
'memulihkannya': 'pulih',
'pemunahan': 'punah',
'memunahkan': 'punah',
'memuncak': 'puncak',
'memuncaknya': 'puncak',
'memuncakkan': 'puncak',
'memuncaki': 'puncak',
'pemuncak': 'puncak',
'pemuncaknya': 'puncak',
'punggahan': 'punggah',
'memunggah': 'punggah',
'pemunggahan': 'punggah',
'muntahan': 'muntah',
'muntahannya': 'muntah',
'memuntahi': 'muntah',
'memuntahinya': 'muntah',
'memuntahkan': 'muntah',
'memuntahkannya': 'muntah',
'dimuntahkan': 'muntah',
'dimuntahkannya': 'muntah',
'dipupuk': 'pupuk',
'dipupuknya': 'pupuk',
'dipupuki': 'pupuk',
'memupuk': 'pupuk',
'memupuknya': 'pupuk',
'memupuki': 'pupuk',
'pemupuk': 'pupuk',
'pemupukkan': 'pupuk',
'pemupukan': 'pupuk',
'terpupuk': 'pupuk',
'terpupuklah': 'pupuk',
'pemupukannya': 'pupuk',
'memupus': 'pupus',
'memupusnya': 'pupus',
'memupuskan': 'pupus',
'memupuskannya': 'pupus',
'terpupus': 'pupus',
'memutar balik': 'putar balik',
'pemutarbalikan': 'putar balik',
'memutarbalikkan': 'putar balik',
'memutarbalikkannya': 'putar balik',
'terputarbalikkan': 'putar balik',
'menabung': 'tabung',
'menabungnya': 'tabung',
'menabunglah': 'tabung',
'menabungkan': 'tabung',
'menabungkannya': 'tabung',
'menabungmu': 'tabung',
'penabung': 'tabung',
'penabungnya': 'tabung',
'penabungan': 'tabung',
'tabungan': 'tabung',
'tabungannya': 'tabung',
'tabunganku': 'tabung',
'tabunganmu': 'tabung',
'menadah': 'tadah',
'menadahnya': 'tadah',
'menadahkan': 'tadah',
'menadahi': 'tadah',
'tadahan': 'tadah',
'penadah': 'tadah',
'penadahnya': 'tadah',
'penadahan': 'tadah',
'bertadah': 'tadah',
'menafikan': 'nafi',
'menafikannya': 'nafi',
'tahunan': 'tahun',
'tahunannya': 'tahun',
'tahunanan': 'tahun',
'menahun': 'tahun',
'menahunnya': 'tahun',
'setahun': 'tahun',
'setahunnya': 'tahun',
'setahunlah': 'tahun',
'setahunan': 'tahun',
'bertahun': 'tahun',
'bertahunan': 'tahun',
'pertahunan': 'tahun',
'bertahun-tahun': 'tahun',
'bertahun-tahunnya': 'tahun',
'bertahun-tahunlah': 'tahun',
'menajak': 'tajak',
'penajakan': 'tajak',
'penajaman': 'tajam',
'penajamanlah': 'tajam',
'penajamanan': 'tajam',
'menajamkan': 'tajam',
'mempertajam': 'tajam',
'mempertajamnya': 'tajam',
'bertakdir': 'takdir',
'menakdirkan': 'takdir',
'menakdirkannya': 'takdir',
'menakdirkanku': 'takdir',
'penakik': 'takik',
'takikan': 'takik',
'menakik': 'takik',
'menakikan': 'takik',
'bertakik': 'takik',
'bertakik-takik': 'takik',
'taksiran': 'taksir',
'taksirannya': 'taksir',
'menaksir': 'taksir',
'menaksirnya': 'taksir',
'menaksirkan': 'taksir',
'menaksirkannya': 'taksir',
'penaksiran': 'taksir',
'penaksirannya': 'taksir',
'menakuk': 'takuk',
'menakukkan': 'takuk',
'menakukan': 'takuk',
'bertakuk': 'takuk',
'menakung': 'takung',
'tertakung': 'takung',
'bertakung': 'takung',
'setala': 'tala',
'penala': 'tala',
'penalaan': 'tala',
'menala': 'tala',
'menalakan': 'tala',
'bertala-tala': 'tala',
'menambah': 'tambah',
'menambahnya': 'tambah',
'menambahkan': 'tambah',
'menambahkannya': 'tambah',
'menambahi': 'tambah',
'menambahan': 'tambah',
'penambah': 'tambah',
'penambahkan': 'tambah',
'penambahan': 'tambah',
'tambahan': 'tambah',
'tambahannya': 'tambah',
'tambahanlah': 'tambah',
'tambahankan': 'tambah',
'tambahani': 'tambah',
'tambahanan': 'tambah',
'bertambah': 'tambah',
'bertambahnya': 'tambah',
'bertambahlah': 'tambah',
'bertambahkan': 'tambah',
'bertambahan': 'tambah',
'menambahinya': 'tambah',
'menambahikan': 'tambah',
'penambahannya': 'tambah',
'penambahanan': 'tambah',
'pertambahan': 'tambah',
'pertambahannya': 'tambah',
'pertambahanan': 'tambah',
'menambahkankan': 'tambah',
'bertambah-tambah': 'tambah',
'menambak': 'tambak',
'menambakkan': 'tambak',
'menambaki': 'tambak',
'menambakan': 'tambak',
'penambak': 'tambak',
'penambakan': 'tambak',
'petambak': 'tambak',
'petambakan': 'tambak',
'bertambak': 'tambak',
'menambat': 'tambat',
'menambatkan': 'tambat',
'menambatkannya': 'tambat',
'tambatan': 'tambat',
'tambatannya': 'tambat',
'bertambat': 'tambat',
'bertambatnya': 'tambat',
'tertambat': 'tambat',
'pertambatan': 'tambat',
'bertambatkan': 'tambat',
'tampalan': 'tampal',
'menampal': 'tampal',
'menampalkan': 'tampal',
'menampali': 'tampal',
'menampung': 'tampung',
'menampungnya': 'tampung',
'menampungkan': 'tampung',
'menampungi': 'tampung',
'menampungan': 'tampung',
'penampung': 'tampung',
'penampungnya': 'tampung',
'penampungan': 'tampung',
'bertampung': 'tampung',
'penampungannya': 'tampung',
'penandasan': 'tandas',
'menandaskan': 'tandas',
'penanda tangan': 'tanda tangan',
'menandatangani': 'tanda tangan',
'menandatanganinya': 'tanda tangan',
'menandatanganii': 'tanda tangan',
'penandatanganan': 'tanda tangan',
'penandatanganannya': 'tanda tangan',
'penandatangananan': 'tanda tangan',
'tertandatangani': 'tanda tangan',
'bertanda tangan': 'tanda tangan',
'menandu': 'tandu',
'menandunya': 'tandu',
'penandu': 'tandu',
'penandukan': 'tandu',
'bertandu': 'tandu',
'pemenang': 'menang',
'pemenangnya': 'menang',
'pemenanglah': 'menang',
'pemenangkan': 'menang',
'pemenangan': 'menang',
'pemenangku': 'menang',
'memenangi': 'menang',
'memenanginya': 'menang',
'pemenangannya': 'menang',
'pemenanganan': 'menang',
'kemenangan': 'menang',
'kemenangannya': 'menang',
'kemenanganlah': 'menang',
'kemenangani': 'menang',
'kemenanganan': 'menang',
'kemenanganku': 'menang',
'kemenanganmu': 'menang',
'memenangkan': 'menang',
'memenangkannya': 'menang',
'memenangkankan': 'menang',
'mempermenangkan': 'menang',
'menangap': 'tangap',
'menangapi': 'tangap',
'tanggapan': 'tanggap',
'tanggapannya': 'tanggap',
'tanggapanku': 'tanggap',
'menanggap': 'tanggap',
'menanggapnya': 'tanggap',
'menanggapi': 'tanggap',
'menanggapan': 'tanggap',
'menanggapinya': 'tanggap',
'menanggapkan': 'tanggap',
'menangguk': 'tangguk',
'penangguk': 'tangguk',
'tertangguk': 'tangguk',
'menangis': 'tangis',
'menangisnya': 'tangis',
'menangislah': 'tangis',
'menangisi': 'tangis',
'tangisan': 'tangis',
'tangisannya': 'tangis',
'tangisanlah': 'tangis',
'tangisanku': 'tangis',
'penangis': 'tangis',
'menangisinya': 'tangis',
'bertangisan': 'tangis',
'menangiskan': 'tangis',
'mempertangis': 'tangis',
'bertangis-tangisan': 'tangis',
'menangkis': 'tangkis',
'menangkisnya': 'tangkis',
'tangkisan': 'tangkis',
'penangkis': 'tangkis',
'penangkisan': 'tangkis',
'tertangkis': 'tangkis',
'tanjakan': 'tanjak',
'tanjakannya': 'tanjak',
'menanjak': 'tanjak',
'menanjaknya': 'tanjak',
'menanjakkan': 'tanjak',
'menanjaki': 'tanjak',
'bertanjak': 'tanjak',
'ditanjakkan': 'tanjak',
'penanti': 'nanti',
'penantikan': 'nanti',
'penantian': 'nanti',
'menanti': 'nanti',
'menantinya': 'nanti',
'menantikan': 'nanti',
'menantikannya': 'nanti',
'menantii': 'nanti',
'menantian': 'nanti',
'menantiku': 'nanti',
'menantimu': 'nanti',
'nantinya': 'nanti',
'penantiannya': 'nanti',
'penantianku': 'nanti',
'bernantian': 'nanti',
'menantikanmu': 'nanti',
'nanti-nantian': 'nanti',
'menanti-nanti': 'nanti',
'menanti-nantikan': 'nanti',
'menanti-nantikannya': 'nanti',
'bernanti-nanti': 'nanti',
'ternanti-nanti': 'nanti',
'bermenantu': 'menantu',
'bermenantukan': 'menantu',
'penapai': 'tapai',
'penapaian': 'tapai',
'menapai': 'tapai',
'tapaian': 'tapai',
'menapis': 'tapis',
'menapiskan': 'tapis',
'tapisan': 'tapis',
'penapis': 'tapis',
'penapisan': 'tapis',
'menarah': 'tarah',
'menarahkannya': 'tarah',
'tarahan': 'tarah',
'penarah': 'tarah',
'bertarah': 'tarah',
'bertarahan': 'tarah',
'penarahan': 'tarah',
'tarian': 'tari',
'tariannya': 'tari',
'tarianku': 'tari',
'menari': 'tari',
'menarinya': 'tari',
'menarilah': 'tari',
'menarikan': 'tarik',
'menarikannya': 'tari',
'penari': 'tari',
'penarinya': 'tari',
'penarilah': 'tari',
'penarikan': 'tarik',
'penarikannya': 'tarik',
'penarian': 'tari',
'bertari': 'tari',
'bertarikan': 'tari',
'tari-menari': 'tari',
'tari-tarian': 'tari',
'tari-tarianan': 'tari',
'menarik': 'tarik',
'menariknya': 'tarik',
'menariklah': 'tarik',
'menarikkan': 'tarik',
'menariki': 'tarik',
'menarikku': 'tarik',
'menarikmu': 'tarik',
'penarik': 'tarik',
'penariknya': 'tarik',
'penarikkan': 'tarik',
'tarikan': 'tarik',
'tarikannya': 'tarik',
'tertarik': 'tarik',
'tertariknya': 'tarik',
'tertariklah': 'tarik',
'tertarikkan': 'tarik',
'tertarikan': 'tarik',
'ketertarikan': 'tarik',
'ketertarikannya': 'tarik',
'ketertarikanku': 'tarik',
'ketertarikanmu': 'tarik',
'tarik-menarik': 'tarik',
'tarik-menariknya': 'tarik',
'bertarik-tarikan': 'tarik',
'menatang': 'tatang',
'menatangi': 'tatang',
'tatapan': 'tatap',
'tatapannya': 'tatap',
'menatap': 'tatap',
'menatapnya': 'tatap',
'menatapkan': 'tatap',
'menatapi': 'tatap',
'menatapku': 'tatap',
'menatapmu': 'tatap',
'penatapan': 'tatap',
'bertatapan': 'tatap',
'bertatap-tatapan': 'tatap',
'menaturalisasi': 'naturalisasi',
'menaturalisasinya': 'naturalisasi',
'menaturalisasikan': 'naturalisasi',
'menaturalisasikannya': 'naturalisasi',
'tawaran': 'tawar',
'tawarannya': 'tawar',
'tawaranku': 'tawar',
'menawar': 'tawar',
'menawarnya': 'tawar',
'menawarlah': 'tawar',
'menawarkan': 'tawar',
'menawarkannya': 'tawar',
'menawari': 'tawar',
'menawaran': 'tawar',
'menawarku': 'tawar',
'penawar': 'tawar',
'penawarnya': 'tawar',
'penawarkan': 'tawar',
'penawaran': 'tawar',
'menawarinya': 'tawar',
'menawariku': 'tawar',
'menawarimu': 'tawar',
'ketawaran': 'tawar',
'penawarannya': 'tawar',
'penawaranlah': 'tawar',
'penawaranan': 'tawar',
'penawaranku': 'tawar',
'penawaranmu': 'tawar',
'bertawaran': 'tawar',
'menawarkankan': 'tawar',
'menawarkanku': 'tawar',
'menawarkanmu': 'tawar',
'tawar jambi': 'tawar',
'tawar-menawar': 'tawar',
'tawar-menawarnya': 'tawar',
'tawar-menawarkan': 'tawar',
'tawar-menawari': 'tawar',
'bertawar-tawaran': 'tawar',
'tayangan': 'tayang',
'tayangannya': 'tayang',
'tayanganlah': 'tayang',
'menayang': 'tayang',
'menayangkan': 'tayang',
'menayangkannya': 'tayang',
'menayangan': 'tayang',
'tertayang': 'tayang',
'tertayangkan': 'tayang',
'penayangan': 'tayang',
'penayangannya': 'tayang',
'penayanganan': 'tayang',
'mencak-mencak': 'mencak',
'mendingan': 'mending',
'mendinganlah': 'mending',
'menebah': 'tebah',
'menebahkan': 'tebah',
'penebang': 'tebang',
'penebangnya': 'tebang',
'penebangan': 'tebang',
'tebangan': 'tebang',
'tebangannya': 'tebang',
'menebang': 'tebang',
'menebangnya': 'tebang',
'menebangkan': 'tebang',
'menebangi': 'tebang',
'menebanginya': 'tebang',
'penebangannya': 'tebang',
'penebar': 'tebar',
'penebarnya': 'tebar',
'penebaran': 'tebar',
'menebar': 'tebar',
'menebarnya': 'tebar',
'menebarkan': 'tebar',
'menebarkannya': 'tebar',
'menebari': 'tebar',
'tebaran': 'tebar',
'tebarannya': 'tebar',
'tertebar': 'tebar',
'tertebaran': 'tebar',
'bertebaran': 'tebar',
'bertebarannya': 'tebar',
'bertebaranlah': 'tebar',
'mempertebarkan': 'tebar',
'penebas': 'tebas',
'penebasan': 'tebas',
'menebas': 'tebas',
'menebasnya': 'tebas',
'menebaskan': 'tebas',
'menebaskannya': 'tebas',
'menebasi': 'tebas',
'tebasan': 'tebas',
'menebat': 'tebat',
'penebatan': 'tebat',
'ditebuk': 'tebuk',
'menebuk': 'tebuk',
'penebuk': 'tebuk',
'tebukan': 'tebuk',
'penebukan': 'tebuk',
'tebusan': 'tebus',
'tebusannya': 'tebus',
'penebus': 'tebus',
'penebusnya': 'tebus',
'penebusan': 'tebus',
'menebus': 'tebus',
'menebusnya': 'tebus',
'menebuslah': 'tebus',
'menebuskan': 'tebus',
'menebusku': 'tebus',
'menebusmu': 'tebus',
'penebusannya': 'tebus',
'menegah': 'tegah',
'menegahnya': 'tegah',
'menegahi': 'tegah',
'tegahan': 'tegah',
'bertegah': 'tegah',
'menegahkan': 'tegah',
'menegak': 'tegak',
'menegaknya': 'tegak',
'menegakkan': 'tegak',
'menegakkannya': 'tegak',
'menegakan': 'tegak',
'tegakan': 'tegak',
'tegakanlah': 'tegak',
'setegak': 'tegak',
'setegaknya': 'tegak',
'penegak': 'tegak',
'penegaknya': 'tegak',
'penegakkan': 'tegak',
'penegakkannya': 'tegak',
'penegakan': 'tegak',
'tertegak': 'tegak',
'bertegak': 'tegak',
'penegakannya': 'tegak',
'penegakanan': 'tegak',
'ketegakan': 'tegak',
'sepertegak': 'tegak',
'tegak-tegak': 'tegak',
'meneguk': 'teguk',
'meneguknya': 'teguk',
'menegukan': 'teguk',
'seteguk': 'teguk',
'terteguk': 'teguk',
'ketegukan': 'teguk',
'menegur': 'tegur',
'menegurnya': 'tegur',
'menegurku': 'tegur',
'teguran': 'tegur',
'tegurannya': 'tegur',
'meneguri': 'tegur',
'keteguran': 'tegur',
'berteguran': 'tegur',
'menegur-neguri': 'tegur',
'menekan': 'tekan',
'menekannya': 'tekan',
'menekankan': 'tekan',
'menekankannya': 'tekan',
'menekanan': 'tekan',
'menekanku': 'tekan',
'menekanmu': 'tekan',
'tekanan': 'tekan',
'tekanannya': 'tekan',
'tekananan': 'tekan',
'tekananku': 'tekan',
'penekan': 'tekan',
'penekannya': 'tekan',
'penekankan': 'tekan',
'penekanan': 'tekan',
'tertekan': 'tekan',
'tertekannya': 'tekan',
'tertekanlah': 'tekan',
'tertekanan': 'tekan',
'bertekan': 'tekan',
'bertekanan': 'tekan',
'penekanannya': 'tekan',
'penekananan': 'tekan',
'menekankankan': 'tekan',
'menekankani': 'tekan',
'bersetekan': 'tekan',
'tertekan-tekan': 'tekan',
'menekap': 'tekap',
'tekapan': 'tekap',
'menekapi': 'tekap',
'bertekap': 'tekap',
'menekapkan': 'tekap',
'menelan': 'telan',
'menelannya': 'telan',
'menelankan': 'telan',
'menelanku': 'telan',
'menelanmu': 'telan',
'tertelan': 'telan',
'tertelannya': 'telan',
'penelanan': 'telan',
'bertelangkup': 'telangkup',
'menelangkupkan': 'telangkup',
'terteleng': 'teleng',
'menelengkan': 'teleng',
'bunga teleng': 'teleng',
'terteleng-teleng': 'teleng',
'menelungkup': 'telungkup',
'menelungkupkan': 'telungkup',
'menelungkupkannya': 'telungkup',
'bertelengkup': 'telungkup',
'tertelungkup': 'telungkup',
'tembakan': 'tembak',
'tembakannya': 'tembak',
'tembakanku': 'tembak',
'tembakanmu': 'tembak',
'petembak': 'tembak',
'penembak': 'tembak',
'penembaknya': 'tembak',
'penembakkan': 'tembak',
'penembakan': 'tembak',
'menembak': 'tembak',
'menembaknya': 'tembak',
'menembakkan': 'tembak',
'menembakkannya': 'tembak',
'menembaki': 'tembak',
'menembakan': 'tembak',
'menembakku': 'tembak',
'menembakmu': 'tembak',
'menembakinya': 'tembak',
'tertembak': 'tembak',
'tertembaknya': 'tembak',
'tertembakan': 'tembak',
'penembakannya': 'tembak',
'penembakanan': 'tembak',
'bertembakan': 'tembak',
'tembak-menembak': 'tembak',
'menemberang': 'temberang',
'menembuk': 'tembuk',
'menembukan': 'tembuk',
'bertembuk-tembuk': 'tembuk',
'tembusan': 'tembus',
'tembusannya': 'tembus',
'menembusi': 'tembus',
'tertembus': 'tembus',
'tertembusnya': 'tembus',
'tertembuskan': 'tembus',
'penembusan': 'tembus',
'penembusannya': 'tembus',
'tempaan': 'tempa',
'penempa': 'tempa',
'penempakan': 'tempa',
'penempaan': 'tempa',
'menempa': 'tempa',
'menempanya': 'tempa',
'menempakan': 'tempa',
'menempai': 'tempa',
'menempaku': 'tempa',
'tempa-menempa': 'tempa',
'tendangan': 'tendang',
'tendangannya': 'tendang',
'tendanganku': 'tendang',
'tendanganmu': 'tendang',
'menendang': 'tendang',
'menendangnya': 'tendang',
'menendangkan': 'tendang',
'menendangkannya': 'tendang',
'menendangi': 'tendang',
'menendangan': 'tendang',
'menendangku': 'tendang',
'menendangmu': 'tendang',
'tertendang': 'tendang',
'tertendangnya': 'tendang',
'tertendang-tendang': 'tendang',
'menenggala': 'tenggala',
'penenggelaman': 'tenggelam',
'penenggelamannya': 'tenggelam',
'menenggelamkan': 'tenggelam',
'menenggelamkannya': 'tenggelam',
'menenggelamkanku': 'tenggelam',
'penenteraman': 'tenteram',
'ketenteraman': 'tenteram',
'menenteramkan': 'tenteram',
'menentu': 'tentu',
'menentunya': 'tentu',
'menentukan': 'tentu',
'menentukannya': 'tentu',
'menentuan': 'tentu',
'penentu': 'tentu',
'penentunya': 'tentu',
'penentukan': 'tentu',
'penentuan': 'tentu',
'bertentu': 'tentu',
'tertentu': 'tentu',
'tertentunya': 'tentu',
'tertentulah': 'tentu',
'tertentui': 'tentu',
'menentui': 'tentu',
'penentuannya': 'tentu',
'ketentuan': 'tentu',
'ketentuannya': 'tentu',
'ketentuanlah': 'tentu',
'ketentuanan': 'tentu',
'menentukankan': 'tentu',
'menentukanku': 'tentu',
'berketentuan': 'tentu',
'bertentu-tentu': 'tentu',
'menepak': 'tepak',
'menepakkan': 'tepak',
'menepak-nepak': 'tepak',
'menepak-nepakkan': 'tepak',
'tepatan': 'tepat',
'menepat': 'tepat',
'menepatkan': 'tepat',
'menepatkannya': 'tepat',
'menepati': 'tepat',
'menepatinya': 'tepat',
'ketepatan': 'tepat',
'ketepatannya': 'tepat',
'pertepatan': 'tepat',
'bertepatan': 'tepat',
'bertepatannya': 'tepat',
'berketepatan': 'tepat',
'menepek': 'tepek',
'bertepek-tepek': 'tepek',
'menepis': 'tepis',
'menepisnya': 'tepis',
'menepiskan': 'tepis',
'menera': 'tera',
'menerakan': 'tera',
'teraan': 'tera',
'bertera': 'tera',
'tertera': 'tera',
'terteranya': 'tera',
'peneraan': 'tera',
'perteraan': 'tera',
'penerang': 'terang',
'penerangnya': 'terang',
'penerangan': 'terang',
'menerang': 'terang',
'menerangkan': 'terang',
'menerangkannya': 'terang',
'menerangi': 'terang',
'menerangan': 'terang',
'meneranginya': 'terang',
'penerangannya': 'terang',
'peneranganan': 'terang',
'keterangan': 'terang',
'keterangannya': 'terang',
'keteranganlah': 'terang',
'keteranganan': 'terang',
'keterangannyalah': 'terang',
'keteranganmu': 'terang',
'menerangkankan': 'terang',
'berpenerangan': 'terang',
'terang-terang': 'terang',
'terang-terangnya': 'terang',
'terang-terangkan': 'terang',
'terang-terangan': 'terang',
'terang-terangannya': 'terang',
'terang-teranganan': 'terang',
'berterang-terang': 'terang',
'berterang-terangan': 'terang',
'terang-terang laras': 'terang',
'penerima': 'terima',
'penerimanya': 'terima',
'penerimalah': 'terima',
'penerimaan': 'terima',
'penerimamu': 'terima',
'menerima': 'terima',
'menerimanya': 'terima',
'menerimalah': 'terima',
'menerimakan': 'terima',
'menerimaan': 'terima',
'menerimaku': 'terima',
'menerimamu': 'terima',
'berterima': 'terima',
'berterimakan': 'terima',
'penerimaannya': 'terima',
'penerimaanmu': 'terima',
'keberterimaan': 'terima',
'menerkam': 'terkam',
'menerkamnya': 'terkam',
'menerkamku': 'terkam',
'penerkam': 'terkam',
'penerkaman': 'terkam',
'terkaman': 'terkam',
'terkamannya': 'terkam',
'terobosan': 'terobos',
'terobosannya': 'terobos',
'menerobos': 'terobos',
'menerobosnya': 'terobos',
'meneroboskan': 'terobos',
'meneroboskannya': 'terobos',
'penerobosan': 'terobos',
'meneroka': 'teroka',
'peneroka': 'teroka',
'menerpa': 'terpa',
'menerpanya': 'terpa',
'menerpakan': 'terpa',
'terpaan': 'terpa',
'terpaannya': 'terpa',
'terusan': 'terus',
'terusannya': 'terus',
'penerus': 'terus',
'penerusnya': 'terus',
'peneruslah': 'terus',
'penerusan': 'terus',
'penerusku': 'terus',
'menerus': 'terus',
'menerusnya': 'terus',
'meneruslah': 'terus',
'meneruskan': 'terus',
'meneruskannya': 'terus',
'menerusi': 'terus',
'penerusannya': 'terus',
'keterusan': 'terus',
'keterusanlah': 'terus',
'meneruskankan': 'terus',
'seterusnya': 'terus',
'terus-menerus': 'terus',
'terus-menerusnya': 'terus',
'terus-terusan': 'terus',
'terus-terusanlah': 'terus',
'terus-terusanan': 'terus',
'menetak': 'tetak',
'menetakan': 'tetak',
'menetakkan': 'tetak',
'bertetakan': 'tetak',
'menetas': 'tetas',
'menetasnya': 'tetas',
'menetaskan': 'tetas',
'menetaskannya': 'tetas',
'penetas': 'tetas',
'penetasi': 'tetas',
'penetasan': 'tetas',
'menetek': 'tetek',
'meneteki': 'tetek',
'menetekkan': 'tetek',
'termengah-mengah': 'mengah',
'mengap-mengap': 'mengap',
'pengasoan': 'aso',
'mengeong': 'ngeong',
'mengepos': 'pos',
'mengeposkan': 'pos',
'mengeposkannya': 'pos',
'pengeposan': 'pos',
'semengga': 'mengga',
'semengga-mengga': 'mengga',
'bermengkal': 'mengkal',
'memengkalkan': 'mengkal',
'kemengkelan': 'mengkelan',
'termengkelan': 'mengkelan',
'cengking-mengking': 'mengking',
'memengkis': 'mengkis',
'ocehan': 'oceh',
'ocehannya': 'oceh',
'mengoceh': 'oceh',
'mengocehi': 'oceh',
'omelan': 'omel',
'omelannya': 'omel',
'mengomel': 'omel',
'mengomeli': 'omel',
'pengomel': 'omel',
'mengomelinya': 'omel',
'mengongkosi': 'ongkos',
'mengongkosinya': 'ongkos',
'perongkosan': 'ongkos',
'uapan': 'uap',
'penguap': 'uap',
'penguapan': 'uap',
'menguapinya': 'uap',
'penguapannya': 'uap',
'teruapkan': 'uap',
'ubah suaian': 'ubah suai',
'pengubahsuaian': 'ubah suai',
'mengubahsuaikan': 'ubah suai',
'ucapan': 'ucap',
'ucapannya': 'ucap',
'ucapanku': 'ucap',
'ucapanmu': 'ucap',
'berucap': 'ucap',
'berucaplah': 'ucap',
'mengucap': 'ucap',
'mengucapnya': 'ucap',
'mengucapkan': 'ucap',
'mengucapkannya': 'ucap',
'mengucapan': 'ucap',
'pengucap': 'ucap',
'pengucapnya': 'ucap',
'pengucapan': 'ucap',
'mengucapi': 'ucap',
'pengucapannya': 'ucap',
'terucapkan': 'ucap',
'mengucapkankan': 'ucap',
'ugutan': 'ugut',
'mengugut': 'ugut',
'diuji': 'uji',
'diujinya': 'uji',
'diujilah': 'uji',
'diujikan': 'uji',
'diujian': 'uji',
'ujian': 'uji',
'ujiannya': 'uji',
'ujiani': 'uji',
'ujianmu': 'uji',
'beruji': 'uji',
'berujian': 'uji',
'teruji': 'uji',
'terujinya': 'uji',
'terujikan': 'uji',
'penguji': 'uji',
'pengujinya': 'uji',
'pengujikan': 'uji',
'pengujian': 'uji',
'menguji': 'uji',
'mengujinya': 'uji',
'mengujikan': 'uji',
'mengujikannya': 'uji',
'mengujii': 'uji',
'mengujian': 'uji',
'mengujimu': 'uji',
'keujian': 'uji',
'pengujiannya': 'uji',
'keterujian': 'uji',
'pengumbuk': 'umbuk',
'mengumbuk': 'umbuk',
'seumpama': 'umpama',
'seumpamanya': 'umpama',
'berumpama': 'umpama',
'mengumpamai': 'umpama',
'perumpamaan': 'umpama',
'perumpamaannya': 'umpama',
'mengumpamakan': 'umpama',
'mengumpamakannya': 'umpama',
'mengumpan': 'umpan',
'mengumpannya': 'umpan',
'mengumpankan': 'umpan',
'mengumpankannya': 'umpan',
'mengumpani': 'umpan',
'pengumpil': 'umpil',
'pengumpilnya': 'umpil',
'pengumpilan': 'umpil',
'mengumpil': 'umpil',
'mengumpilkan': 'umpil',
'mengumpilan': 'umpil',
'seumumnya': 'umum',
'memperumum': 'umum',
'pengumuman': 'umum',
'pengumumannya': 'umum',
'pengumumanlah': 'umum',
'pengumumanan': 'umum',
'mengumumkan': 'umum',
'mengumumkannya': 'umum',
'mengumumkankan': 'umum',
'undangan': 'undang',
'undangannya': 'undang',
'undanganlah': 'undang',
'undanganan': 'undang',
'undanganku': 'undang',
'undanganmu': 'undang',
'berundang': 'undang',
'pengundang': 'undang',
'pengundangnya': 'undang',
'pengundangan': 'undang',
'undang-undang': 'undang',
'undang-undangnya': 'undang',
'undang-undanglah': 'undang',
'undang-undangkan': 'undang',
'undang-undangi': 'undang',
'undang-undangan': 'undang',
'pengundang-undang': 'undang',
'pengundang-undangan': 'undang',
'perundang-undangan': 'undang',
'perundang-undangannya': 'undang',
'perundang-undanganan': 'undang',
'undian': 'undi',
'undiannya': 'undi',
'berundi': 'undi',
'pengundi': 'undi',
'pengundian': 'undi',
'mengundi': 'undi',
'mengundinya': 'undi',
'pengundiannya': 'undi',
'memperundikan': 'undi',
'mengundur': 'undur',
'mengundurnya': 'undur',
'mengundurkan': 'undur',
'mengundurkannya': 'undur',
'mengunduran': 'undur',
'pengunduran': 'undur',
'pengundurannya': 'undur',
'termengung': 'mengung',
'mengunggis': 'unggis',
'pengunggis': 'unggis',
'unggunan': 'unggun',
'berunggun': 'unggun',
'mengunggun': 'unggun',
'mengunggunkan': 'unggun',
'berunggun-unggun': 'unggun',
'ungkaian': 'ungkai',
'mengungkai': 'ungkai',
'ungkapan': 'ungkap',
'ungkapannya': 'ungkap',
'terungkap': 'ungkap',
'terungkapnya': 'ungkap',
'terungkaplah': 'ungkap',
'terungkapkan': 'ungkap',
'mengungkap': 'ungkap',
'mengungkapnya': 'ungkap',
'mengungkapkan': 'ungkap',
'mengungkapkannya': 'ungkap',
'mengungkapan': 'ungkap',
'mengungkapi': 'ungkap',
'pengungkapan': 'ungkap',
'pengungkapannya': 'ungkap',
'mengungkapkankan': 'ungkap',
'mengungkapkanan': 'ungkap',
'terungkap-ungkap': 'ungkap',
'mengungkit': 'ungkit',
'mengungkitnya': 'ungkit',
'pengungkit': 'ungkit',
'pengungkitnya': 'ungkit',
'pengungkitan': 'ungkit',
'ungkit-ungkit': 'ungkit',
'mengungkit-ungkit': 'ungkit',
'mengungkit-ungkitnya': 'ungkit',
'mengunjuk': 'unjuk',
'mengunjukkan': 'unjuk',
'mengunjukan': 'unjuk',
'pengunjukan': 'unjuk',
'sepengunjuk': 'unjuk',
'mengunting': 'unting',
'unting-unting': 'unting',
'upahan': 'upah',
'berupah': 'upah',
'mengupah': 'upah',
'mengupahnya': 'upah',
'mengupahi': 'upah',
'pengupahan': 'upah',
'pengupahannya': 'upah',
'mengupahkan': 'upah',
'upah-mengupah': 'upah',
'uraian': 'urai',
'uraiannya': 'urai',
'terurai': 'urai',
'terurainya': 'urai',
'teruraikan': 'urai',
'berurai': 'urai',
'beruraikan': 'urai',
'beruraian': 'urai',
'mengurai': 'urai',
'mengurainya': 'urai',
'menguraikan': 'urai',
'menguraikannya': 'urai',
'peruraian': 'urai',
'penguraian': 'urai',
'penguraiannya': 'urai',
'mengurup': 'urup',
'urup-urup': 'urup',
'urup-urupan': 'urup',
'keurus': 'urus',
'urusan': 'urus',
'urusannya': 'urus',
'urusanlah': 'urus',
'urusani': 'urus',
'urusanku': 'urus',
'urusanmu': 'urus',
'urusan-ku': 'urus',
'terurus': 'urus',
'terurusnya': 'urus',
'keurusan': 'urus',
'pengurus': 'urus',
'pengurusnya': 'urus',
'penguruslah': 'urus',
'pengurusi': 'urus',
'pengurusku': 'urus',
'pengurusmu': 'urus',
'mengurusinya': 'urus',
'mengurusiku': 'urus',
'mengurusimu': 'urus',
'berurusan': 'urus',
'urus-urus': 'urus',
'urus-urusan': 'urus',
'kepengurusan': 'urus',
'kepengurusannya': 'urus',
'kepengurusanan': 'urus',
'kepengurusannyalah': 'urus',
'mengusainya': 'usai',
'mengusaikan': 'usai',
'mengusap': 'usap',
'mengusapnya': 'usap',
'mengusapkan': 'usap',
'mengusapkannya': 'usap',
'mengusapi': 'usap',
'usikan': 'usik',
'terusik': 'usik',
'terusiknya': 'usik',
'pengusik': 'usik',
'pengusiknya': 'usik',
'mengusik': 'usik',
'mengusiknya': 'usik',
'mengusikku': 'usik',
'mengusikmu': 'usik',
'usiran': 'usir',
'usirannya': 'usir',
'terusir': 'usir',
'terusirnya': 'usir',
'pengusir': 'usir',
'pengusirnya': 'usir',
'pengusiran': 'usir',
'mengusir': 'usir',
'mengusirnya': 'usir',
'mengusiri': 'usir',
'mengusiran': 'usir',
'mengusirku': 'usir',
'mengusirmu': 'usir',
'pengusirannya': 'usir',
'usulan': 'usul',
'usulannya': 'usul',
'usulanku': 'usul',
'usulanmu': 'usul',
'pengusul': 'usul',
'pengusulnya': 'usul',
'pengusulan': 'usul',
'mengusul': 'usul',
'mengusulkan': 'usul',
'mengusulkannya': 'usul',
'mengusulan': 'usul',
'pengusuli': 'usul',
'mengusuli': 'usul',
'pengusulannya': 'usul',
'usungan': 'usung',
'usungannya': 'usung',
'berusung': 'usung',
'pengusung': 'usung',
'pengusungnya': 'usung',
'pengusunglah': 'usung',
'pengusungan': 'usung',
'mengusung': 'usung',
'mengusungnya': 'usung',
'mengusungkan': 'usung',
'mengusungi': 'usung',
'pengusungannya': 'usung',
'mengutara': 'utara',
'mengutarakan': 'utara',
'mengutarakannya': 'utara',
'pengutaraan': 'utara',
'utusan': 'utus',
'utusannya': 'utus',
'mengutus': 'utus',
'mengutusnya': 'utus',
'mengutuskan': 'utus',
'mengutusku': 'utus',
'mengutusmu': 'utus',
'perutusan': 'utus',
'perutusannya': 'utus',
'pengutusan': 'utus',
'meniarap': 'tiarap',
'tertiarap': 'tiarap',
'bertiarap': 'tiarap',
'meniarapkan': 'tiarap',
'menikah': 'nikah',
'menikahnya': 'nikah',
'menikahlah': 'nikah',
'menikahkan': 'nikah',
'menikahkannya': 'nikah',
'menikahi': 'nikah',
'menikahinya': 'nikah',
'menikahiku': 'nikah',
'menikahimu': 'nikah',
'pernikahan': 'nikah',
'pernikahannya': 'nikah',
'pernikahanlah': 'nikah',
'pernikahanan': 'nikah',
'pernikahanku': 'nikah',
'pernikahanmu': 'nikah',
'menikahkanku': 'nikah',
'menikam': 'tikam',
'menikamnya': 'tikam',
'menikamkan': 'tikam',
'menikamkannya': 'tikam',
'menikami': 'tikam',
'menikamku': 'tikam',
'menikammu': 'tikam',
'penikam': 'tikam',
'penikaman': 'tikam',
'tikaman': 'tikam',
'tertikam': 'tikam',
'penikamannya': 'tikam',
'pertikaman': 'tikam',
'tikam-menikam': 'tikam',
'bertikam-tikaman': 'tikam',
'penikmat': 'nikmat',
'penikmatnya': 'nikmat',
'penikmati': 'nikmat',
'penikmatan': 'nikmat',
'menikmati': 'nikmat',
'menikmatinya': 'nikmat',
'menikmatilah': 'nikmat',
'menikmatii': 'nikmat',
'menikmatiku': 'nikmat',
'menikmatimu': 'nikmat',
'kenikmatan': 'nikmat',
'kenikmatannya': 'nikmat',
'kenikmatanlah': 'nikmat',
'penilik': 'tilik',
'penilikan': 'tilik',
'menilik': 'tilik',
'meniliknya': 'tilik',
'meniliki': 'tilik',
'tilikan': 'tilik',
'tilikannya': 'tilik',
'tilik-menilik': 'tilik',
'menimang': 'timang',
'menimangnya': 'timang',
'ditimang': 'timang',
'menimangkan': 'timang',
'menimang-nimang': 'timang',
'menimang-nimangnya': 'timang',
'timang-timangan': 'timang',
'timbangan': 'timbang',
'timbangannya': 'timbang',
'timbanganku': 'timbang',
'setimbang': 'timbang',
'ketimbang': 'timbang',
'ketimbangnya': 'timbang',
'ketimbangkan': 'timbang',
'ketimbangan': 'timbang',
'ketimbangku': 'timbang',
'menimbang': 'timbang',
'menimbangnya': 'timbang',
'menimbangkan': 'timbang',
'menimbangkannya': 'timbang',
'menimbangi': 'timbang',
'penimbang': 'timbang',
'penimbangan': 'timbang',
'bertimbang': 'timbang',
'bertimbangkan': 'timbang',
'setimbangan': 'timbang',
'bertimbangan': 'timbang',
'pertimbangan': 'timbang',
'pertimbangannya': 'timbang',
'pertimbanganlah': 'timbang',
'pertimbangankan': 'timbang',
'pertimbanganan': 'timbang',
'pertimbanganku': 'timbang',
'kesetimbangan': 'timbang',
'kesetimbangannya': 'timbang',
'menyetimbangkan': 'timbang',
'mempertimbangkan': 'timbang',
'mempertimbangkannya': 'timbang',
'mempertimbangkankan': 'timbang',
'mempertimbangkanku': 'timbang',
'menimbang-nimbang': 'timbang',
'menimbang-nimbangnya': 'timbang',
'timbang-menimbang': 'timbang',
'menimbus': 'timbus',
'menimbusi': 'timbus',
'tertimbus': 'timbus',
'menimpa': 'timpa',
'menimpanya': 'timpa',
'menimpakan': 'timpa',
'menimpakannya': 'timpa',
'menimpai': 'timpa',
'menimpanyalah': 'timpa',
'menimpaku': 'timpa',
'menimpamu': 'timpa',
'ditimpa': 'timpa',
'ditimpanya': 'timpa',
'ditimpakan': 'timpa',
'ditimpakannya': 'timpa',
'timpaan': 'timpa',
'tertimpa': 'timpa',
'tertimpanya': 'timpa',
'tertimpalah': 'timpa',
'timpa-menimpa': 'timpa',
'bertimpa-timpa': 'timpa',
'menindik': 'tindik',
'menindiknya': 'tindik',
'menindikan': 'tindik',
'bertindik': 'tindik',
'tinggalan': 'tinggal',
'tinggalannya': 'tinggal',
'peninggal': 'tinggal',
'peninggalkan': 'tinggal',
'peninggalan': 'tinggal',
'meninggal': 'tinggal',
'meninggalnya': 'tinggal',
'meninggalkan': 'tinggal',
'meninggalkannya': 'tinggal',
'meninggali': 'tinggal',
'meninggalan': 'tinggal',
'meninggalku': 'tinggal',
'tertinggal': 'tinggal',
'tertinggalnya': 'tinggal',
'tertinggalkan': 'tinggal',
'tertinggalan': 'tinggal',
'meninggalinya': 'tinggal',
'pertinggal': 'tinggal',
'pertinggalnya': 'tinggal',
'pertinggalan': 'tinggal',
'bertinggal': 'tinggal',
'sepeninggal': 'tinggal',
'sepeninggalnya': 'tinggal',
'sepeninggalan': 'tinggal',
'ketinggalan': 'tinggal',
'ketinggalannya': 'tinggal',
'peninggalannya': 'tinggal',
'peninggalanan': 'tinggal',
'meninggalkankan': 'tinggal',
'meninggalkanku': 'tinggal',
'meninggalkanmu': 'tinggal',
'ketertinggalan': 'tinggal',
'ketertinggalannya': 'tinggal',
'ketertinggalanku': 'tinggal',
'peninjau': 'tinjau',
'peninjaunya': 'tinjau',
'peninjaukan': 'tinjau',
'peninjauan': 'tinjau',
'meninjau': 'tinjau',
'meninjaunya': 'tinjau',
'meninjaui': 'tinjau',
'meninjauan': 'tinjau',
'tinjauan': 'tinjau',
'tinjauannya': 'tinjau',
'peninjauannya': 'tinjau',
'peninjauanan': 'tinjau',
'tinjau-meninjau': 'tinjau',
'bertinjau-tinjauan': 'tinjau',
'penipu': 'tipu',
'penipunya': 'tipu',
'penipuan': 'tipu',
'menipu': 'tipu',
'menipunya': 'tipu',
'menipukan': 'tipu',
'menipuku': 'tipu',
'menipumu': 'tipu',
'tipuan': 'tipu',
'tipuannya': 'tipu',
'penipuannya': 'tipu',
'penipuanlah': 'tipu',
'bertipuan': 'tipu',
'peniru': 'tiru',
'penirunya': 'tiru',
'peniruan': 'tiru',
'tiruan': 'tiru',
'tiruannya': 'tiru',
'meniru': 'tiru',
'menirunya': 'tiru',
'menirulah': 'tiru',
'menirukan': 'tiru',
'menirukannya': 'tiru',
'menirui': 'tiru',
'menirumu': 'tiru',
'meniru-niru': 'tiru',
'tiru-tiruan': 'tiru',
'menisik': 'tisik',
'tisikan': 'tisik',
'menisiki': 'tisik',
'menitik': 'titik',
'menitikkan': 'titik',
'menitikan': 'titik',
'bertitik': 'titik',
'menitiki': 'titik',
'bertitik-titik': 'titik',
'penitikberatan': 'titik berat',
'menitikberatkan': 'titik berat',
'menitikberatkannya': 'titik berat',
'titisan': 'titis',
'titisannya': 'titis',
'menitis': 'titis',
'menitiskan': 'titis',
'penitisan': 'titis',
'ketitisan': 'titis',
'bernoda': 'noda',
'bernodakan': 'noda',
'ternoda': 'noda',
'ternodanya': 'noda',
'ternodakan': 'noda',
'ternodai': 'noda',
'menodai': 'noda',
'menodainya': 'noda',
'penokok': 'tokok',
'menokok': 'tokok',
'bertokok': 'tokok',
'tokok-menokok': 'tokok',
'penolong': 'tolong',
'penolongnya': 'tolong',
'penolongi': 'tolong',
'penolongan': 'tolong',
'penolongmu': 'tolong',
'menolong': 'tolong',
'menolongnya': 'tolong',
'menolonglah': 'tolong',
'menolongku': 'tolong',
'menolongmu': 'tolong',
'tertolong': 'tolong',
'tertolongnya': 'tolong',
'tertolongkan': 'tolong',
'tertolongan': 'tolong',
'ketolongan': 'tolong',
'pertolongan': 'tolong',
'pertolongannya': 'tolong',
'pertolongankan': 'tolong',
'pertolonganku': 'tolong',
'pertolonganmu': 'tolong',
'pertolongan-mu': 'tolong',
'tolong-menolong': 'tolong',
'tolong-menolonglah': 'tolong',
'bertolong-tolongan': 'tolong',
'tonjolan': 'tonjol',
'tonjolannya': 'tonjol',
'menonjol': 'tonjol',
'menonjolnya': 'tonjol',
'menonjolkan': 'tonjol',
'menonjolkannya': 'tonjol',
'menonjolan': 'tonjol',
'bertonjol': 'tonjol',
'bertonjolan': 'tonjol',
'tertonjol': 'tonjol',
'tertonjolkan': 'tonjol',
'penonjolan': 'tonjol',
'penonjolannya': 'tonjol',
'bertonjol-tonjol': 'tonjol',
'menonjol-nonjolkan': 'tonjol',
'tontonan': 'tonton',
'tontonannya': 'tonton',
'penonton': 'tonton',
'penontonnya': 'tonton',
'menonton': 'tonton',
'menontonnya': 'tonton',
'menontonkan': 'tonton',
'menontonkannya': 'tonton',
'menontoni': 'tonton',
'menontonku': 'tonton',
'menontonmu': 'tonton',
'kepenontonan': 'tonton',
'mempertontonkan': 'tonton',
'mempertontonkannya': 'tonton',
'mempertontonkankan': 'tonton',
'penopang': 'topang',
'penopangnya': 'topang',
'topangan': 'topang',
'menopang': 'topang',
'menopangnya': 'topang',
'menopangkan': 'topang',
'menopangku': 'topang',
'menopangmu': 'topang',
'bertopang': 'topang',
'bertopangkan': 'topang',
'torehan': 'toreh',
'torehannya': 'toreh',
'menoreh': 'toreh',
'menorehnya': 'toreh',
'menorehkan': 'toreh',
'menorehkannya': 'toreh',
'menorehan': 'toreh',
'penoreh': 'toreh',
'penorehnya': 'toreh',
'penorehan': 'toreh',
'stensilan': 'stensil',
'menstensil': 'stensil',
'penswastaan': 'swasta',
'menswastakan': 'swasta',
'kementahan': 'mentah',
'mementahkan': 'mentah',
'mementahkannya': 'mentah',
'mentah-mentah': 'mentah',
'kementakan': 'mentak',
'sementang': 'mentang',
'sementangkan': 'mentang',
'mentang-mentang': 'mentang',
'mentang-mentanglah': 'mentang',
'sementang-mentang': 'mentang',
'mementegai': 'mentega',
'kementerengan': 'mentereng',
'menuam': 'tuam',
'menuami': 'tuam',
'bertuam': 'tuam',
'tuangan': 'tuang',
'tuangannya': 'tuang',
'dituang': 'tuang',
'dituangnya': 'tuang',
'dituangkan': 'tuang',
'dituangkannya': 'tuang',
'dituangi': 'tuang',
'dituangan': 'tuang',
'menuang': 'tuang',
'menuangnya': 'tuang',
'menuangkan': 'tuang',
'menuangkannya': 'tuang',
'menuangi': 'tuang',
'menuanginya': 'tuang',
'bertuang': 'tuang',
'bertuangan': 'tuang',
'penuangan': 'tuang',
'penuangannya': 'tuang',
'ketuangan': 'tuang',
'tubian': 'tubi',
'menubikan': 'tubi',
'bertubi-tubi': 'tubi',
'bertubi-tubinya': 'tubi',
'mempertubikan': 'tubi',
'mempertubi-tubi': 'tubi',
'mempertubi-tubikan': 'tubi',
'tugalan': 'tugal',
'menugal': 'tugal',
'menugalkan': 'tugal',
'menujah': 'tujah',
'menujahkan': 'tujah',
'penuju': 'tuju',
'penujukan': 'tuju',
'penujukannya': 'tuju',
'setuju': 'tuju',
'setujunya': 'tuju',
'setujulah': 'tuju',
'setujui': 'tuju',
'setujuan': 'tuju',
'menuju': 'tuju',
'menujunya': 'tuju',
'menujukan': 'tuju',
'menujukannya': 'tuju',
'menujui': 'tuju',
'menujuku': 'tuju',
'tujuan': 'tuju',
'tujuannya': 'tuju',
'tujuanku': 'tuju',
'tujuanmu': 'tuju',
'tertuju': 'tuju',
'tertujunya': 'tuju',
'tertujuan': 'tuju',
'setujuannya': 'tuju',
'bersetuju': 'tuju',
'bersetujuan': 'tuju',
'bertujuan': 'tuju',
'bertujuannya': 'tuju',
'bertujuani': 'tuju',
'kesetujuan': 'tuju',
'kesetujuannya': 'tuju',
'menyetujui': 'tuju',
'menyetujuinya': 'tuju',
'persetujuan': 'tuju',
'persetujuannya': 'tuju',
'persetujuanmu': 'tuju',
'menyetujukan': 'tuju',
'mempersetujukan': 'tuju',
'menukul': 'tukul',
'penukul': 'tukul',
'menular': 'tular',
'menularnya': 'tular',
'menularkan': 'tular',
'menularkannya': 'tular',
'menulari': 'tular',
'menularan': 'tular',
'menularinya': 'tular',
'tertulari': 'tular',
'penularan': 'tular',
'penularannya': 'tular',
'penularanan': 'tular',
'ketularan': 'tular',
'menumbang': 'tumbang',
'menumbangkan': 'tumbang',
'menumbangkannya': 'tumbang',
'tumpasan': 'tumpas',
'penumpas': 'tumpas',
'penumpasan': 'tumpas',
'menumpas': 'tumpas',
'menumpasnya': 'tumpas',
'menumpaskan': 'tumpas',
'penumpasannya': 'tumpas',
'penunaian': 'tunai',
'menunaikan': 'tunai',
'menunaikannya': 'tunai',
'pertunaian': 'tunai',
'penunda': 'tunda',
'penundaan': 'tunda',
'menunda': 'tunda',
'menundanya': 'tunda',
'menundaan': 'tunda',
'bertunda': 'tunda',
'tertunda': 'tunda',
'tertundanya': 'tunda',
'penundaannya': 'tunda',
'penundaani': 'tunda',
'menundakan': 'tunda',
'menunda-nunda': 'tunda',
'menunda-nundanya': 'tunda',
'bertunda-tunda': 'tunda',
'menunduk': 'tunduk',
'menunduklah': 'tunduk',
'menundukkan': 'tunduk',
'menundukkannya': 'tunduk',
'menundukan': 'tunduk',
'petunduk': 'tunduk',
'penundukan': 'tunduk',
'ketundukan': 'tunduk',
'ketertundukan': 'tunduk',
'ketertundukannya': 'tunduk',
'menunduk-nunduk': 'tunduk',
'menunggang': 'tunggang',
'menunggangnya': 'tunggang',
'menunggangi': 'tunggang',
'tunggangan': 'tunggang',
'tunggangannya': 'tunggang',
'penunggang': 'tunggang',
'penunggangnya': 'tunggang',
'penunggangan': 'tunggang',
'bertunggang': 'tunggang',
'menungganginya': 'tunggang',
'tertunggang': 'tunggang',
'bersetunggang': 'tunggang',
'menunggangkan': 'tunggang',
'tunggang-tunggit': 'tunggang',
'tunggang-tunggik': 'tunggang',
'tunggang-tungging': 'tunggang',
'mempertunggangkan': 'tunggang',
'penunggu': 'tunggu',
'penunggunya': 'tunggu',
'penungguan': 'tunggu',
'menunggu': 'tunggu',
'menunggunya': 'tunggu',
'menunggulah': 'tunggu',
'menunggukan': 'tunggu',
'menunggui': 'tunggu',
'menungguku': 'tunggu',
'menunggumu': 'tunggu',
'menungguinya': 'tunggu',
'menungguiku': 'tunggu',
'bertunggu': 'tunggu',
'menuntun': 'tuntun',
'menuntunnya': 'tuntun',
'menuntunkan': 'tuntun',
'menuntunku': 'tuntun',
'menuntunmu': 'tuntun',
'penuntun': 'tuntun',
'penuntunnya': 'tuntun',
'penuntunan': 'tuntun',
'tuntunan': 'tuntun',
'tuntunannya': 'tuntun',
'bertuntun': 'tuntun',
'menuris': 'turis',
'seturut': 'turut',
'menurut': 'turut',
'menurutnya': 'turut',
'menurutkan': 'turut',
'menuruti': 'turut',
'menurutan': 'turut',
'menurutnyalah': 'turut',
'menurutku': 'turut',
'menurutmu': 'turut',
'menurut-mu': 'turut',
'penurut': 'turut',
'penurutnya': 'turut',
'penurutan': 'turut',
'turutan': 'turut',
'menurutinya': 'turut',
'berturuti': 'turut',
'perturutan': 'turut',
'perturutannya': 'turut',
'turut-menurut': 'turut',
'turut-turutan': 'turut',
'berturut-turut': 'turut',
'berturut-turutnya': 'turut',
'berturut-turutlah': 'turut',
'memperturutkan': 'turut',
'memperturut-turutkan': 'turut',
'menusuk': 'tusuk',
'menusuknya': 'tusuk',
'menusukkan': 'tusuk',
'menusukkannya': 'tusuk',
'menusuki': 'tusuk',
'menusukan': 'tusuk',
'menusukku': 'tusuk',
'menusukmu': 'tusuk',
'tertusuk': 'tusuk',
'tertusuknya': 'tusuk',
'menusuk-nusuk': 'tusuk',
'menusuk-nusukkan': 'tusuk',
'menusuk-nusukan': 'tusuk',
'menutup': 'tutup',
'menutupnya': 'tutup',
'menutupkan': 'tutup',
'menutupi': 'tutup',
'menutupan': 'tutup',
'menutupku': 'tutup',
'tutupan': 'tutup',
'tutupannya': 'tutup',
'penutup': 'tutup',
'penutupnya': 'tutup',
'penutupkan': 'tutup',
'penutupi': 'tutup',
'penutupan': 'tutup',
'tertutup': 'tutup',
'tertutupnya': 'tutup',
'tertutuplah': 'tutup',
'tertutupi': 'tutup',
'bertutup': 'tutup',
'bertutupkan': 'tutup',
'menutupinya': 'tutup',
'penutupannya': 'tutup',
'penutupani': 'tutup',
'ketertutupan': 'tutup',
'ketertutupannya': 'tutup',
'tersadar': 'sadar',
'tersadarkan': 'sadar',
'menyadar': 'sadar',
'menyadarkan': 'sadar',
'menyadarkannya': 'sadar',
'menyadari': 'sadar',
'menyadarinya': 'sadar',
'menyadarilah': 'sadar',
'kesadaran': 'sadar',
'kesadarannya': 'sadar',
'kesadaranku': 'sadar',
'penyadaran': 'sadar',
'penyadaranlah': 'sadar',
'menyadarkanku': 'sadar',
'menyadarkanmu': 'sadar',
'sahutan': 'sahut',
'sahutannya': 'sahut',
'bersahut': 'sahut',
'bersahutan': 'sahut',
'penyahut': 'sahut',
'menyahut': 'sahut',
'menyahutnya': 'sahut',
'menyahuti': 'sahut',
'menyahutinya': 'sahut',
'penyahutan': 'sahut',
'sahut-menyahut': 'sahut',
'bersahut-sahutan': 'sahut',
'saingan': 'saing',
'saingannya': 'saing',
'sainganku': 'saing',
'sainganmu': 'saing',
'sesaing': 'saing',
'pesaing': 'saing',
'pesaingnya': 'saing',
'pesaingan': 'saing',
'pesaingku': 'saing',
'penyaing': 'saing',
'bersaing': 'saing',
'bersaingnya': 'saing',
'bersainglah': 'saing',
'bersaingan': 'saing',
'menyaingi': 'saing',
'menyainginya': 'saing',
'menyaingikan': 'saing',
'menyaingiku': 'saing',
'tersaingi': 'saing',
'persaingan': 'saing',
'persaingannya': 'saing',
'persainganlah': 'saing',
'persainganan': 'saing',
'bersaingannya': 'saing',
'mempersaingkan': 'saing',
'saing-menyaing': 'saing',
'penyalahgunaan': 'salah guna',
'penyalahgunaannya': 'salah guna',
'menyalahgunakan': 'salah guna',
'menyalahgunakannya': 'salah guna',
'salaian': 'salai',
'tersalai': 'salai',
'bersalai': 'salai',
'saluran': 'salur',
'salurannya': 'salur',
'salurankan': 'salur',
'saluranku': 'salur',
'penyalur': 'salur',
'penyalurnya': 'salur',
'penyalurkan': 'salur',
'penyaluran': 'salur',
'tersalur': 'salur',
'tersalurnya': 'salur',
'tersalurkan': 'salur',
'tersalurkannya': 'salur',
'tersaluri': 'salur',
'penyalurannya': 'salur',
'penyaluranlah': 'salur',
'penyaluranan': 'salur',
'menyalurkan': 'salur',
'menyalurkannya': 'salur',
'menyalurkankannya': 'salur',
'penyamak': 'samak',
'penyamaknya': 'samak',
'penyamakan': 'samak',
'menyamak': 'samak',
'menyamakkan': 'samak',
'kenyamanan': 'nyaman',
'kenyamanannya': 'nyaman',
'kenyamananlah': 'nyaman',
'kenyamananan': 'nyaman',
'kenyamananmu': 'nyaman',
'menyamankan': 'saman',
'menyamankannya': 'saman',
'sambaran': 'sambar',
'sambarannya': 'sambar',
'menyambar': 'sambar',
'menyambarnya': 'sambar',
'menyambarku': 'sambar',
'penyambar': 'sambar',
'tersambar': 'sambar',
'tersambarnya': 'sambar',
'bersambaran': 'sambar',
'sambar-menyambar': 'sambar',
'menyambar-nyambar': 'sambar',
'bersambar-sambaran': 'sambar',
'sambutan': 'sambut',
'sambutannya': 'sambut',
'menyambut': 'sambut',
'menyambutnya': 'sambut',
'menyambutkan': 'sambut',
'menyambutan': 'sambut',
'menyambutku': 'sambut',
'menyambutmu': 'sambut',
'bersambut': 'sambut',
'bersambutan': 'sambut',
'penyambut': 'sambut',
'penyambutnya': 'sambut',
'penyambutkan': 'sambut',
'penyambutan': 'sambut',
'penyambutannya': 'sambut',
'sambut-menyambut': 'sambut',
'bersambut-sambutan': 'sambut',
'penyampah': 'sampah',
'menyampah': 'sampah',
'menyampahi': 'sampah',
'penyampahan': 'sampah',
'persampahan': 'sampah',
'mempersampahkan': 'sampah',
'tersampang': 'sampang',
'menyampang': 'sampang',
'menyampangi': 'sampang',
'menyampu': 'sampu',
'menyampuk': 'sampuk',
'bersampuk': 'sampuk',
'tersampuk': 'sampuk',
'kesampukan': 'sampuk',
'menyampukkan': 'sampuk',
'samunan': 'samun',
'menyamun': 'samun',
'penyamun': 'samun',
'kesamunan': 'samun',
'menyamuni': 'samun',
'penyamunan': 'samun',
'bersandiwara': 'sandiwara',
'penyandiwaraan': 'sandiwara',
'menyandiwarakan': 'sandiwara',
'penyangga': 'sangga',
'penyangganya': 'sangga',
'penyanggaan': 'sangga',
'bersangga': 'sangga',
'menyangga': 'sangga',
'menyangganya': 'sangga',
'bersanggakan': 'sangga',
'sangkaan': 'sangka',
'sangkaannya': 'sangka',
'tersangka': 'sangka',
'tersangkanya': 'sangka',
'tersangkalah': 'sangka',
'tersangkakan': 'sangka',
'tersangkai': 'sangka',
'tersangkaan': 'sangka',
'menyangka': 'sangka',
'menyangkanya': 'sangka',
'menyangkakan': 'sangkak',
'menyangkakannya': 'sangka',
'bersangka': 'sangka',
'sangkalan': 'sangkal',
'sangkalannya': 'sangkal',
'bersangkal': 'sangkal',
'penyangkal': 'sangkal',
'penyangkalan': 'sangkal',
'menyangkal': 'sangkal',
'menyangkalnya': 'sangkal',
'menyangkali': 'sangkal',
'penyangkalannya': 'sangkal',
'penyangkalanku': 'sangkal',
'sangkutan': 'sangkut',
'sangkutannya': 'sangkut',
'penyangkut': 'sangkut',
'penyangkutnya': 'sangkut',
'bersangkut': 'sangkut',
'bersangkutkan': 'sangkut',
'bersangkutan': 'sangkut',
'menyangkut': 'sangkut',
'menyangkutnya': 'sangkut',
'menyangkutkan': 'sangkut',
'menyangkutkannya': 'sangkut',
'tersangkut': 'sangkut',
'tersangkutnya': 'sangkut',
'tersangkutan': 'sangkut',
'persangkutan': 'sangkut',
'bersangkutannya': 'sangkut',
'bersangkutanlah': 'sangkut',
'mempersangkutkan': 'sangkut',
'sangkut-menyangkut': 'sangkut',
'menyangkut-nyangkutkan': 'sangkut',
'sanjungan': 'sanjung',
'sanjungannya': 'sanjung',
'tersanjung': 'sanjung',
'tersanjungnya': 'sanjung',
'menyanjung': 'sanjung',
'menyanjungnya': 'sanjung',
'menyanjungku': 'sanjung',
'penyanjung': 'sanjung',
'penyanjungan': 'sanjung',
'menyanjung-nyanjung': 'sanjung',
'menyanjung-nyanjungkan': 'sanjung',
'sapaan': 'sapa',
'sapaannya': 'sapa',
'disapa': 'sapa',
'disapanya': 'sapa',
'disapai': 'sapa',
'menyapa': 'sapa',
'menyapanya': 'sapa',
'menyapalah': 'sapa',
'menyapakan': 'sapa',
'menyapai': 'sapa',
'menyapaku': 'sapa',
'bersapa': 'sapa',
'bersapaan': 'sapa',
'tersapa': 'sapa',
'sapa-menyapa': 'sapa',
'bersapa-sapaan': 'sapa',
'menyara': 'sara',
'menyarakan': 'sarak',
'menyarakannya': 'sara',
'bersara': 'sara',
'bersarakan': 'sarak',
'menyarai': 'sara',
'tersara bara': 'sara',
'saranan': 'saran',
'saranannya': 'saran',
'saranani': 'saran',
'menyarani': 'saran',
'menyarankan': 'saran',
'menyarankannya': 'saran',
'menyarankankan': 'saran',
'menyarankanku': 'saran',
'sari-sari': 'sari',
'sari-sarinya': 'sari',
'menyarikan': 'sari',
'sayatan': 'sayat',
'sayatannya': 'sayat',
'sesayat': 'sayat',
'tersayat': 'sayat',
'tersayatnya': 'sayat',
'menyayat': 'sayat',
'menyayatnya': 'sayat',
'menyayatkan': 'sayat',
'menyayati': 'sayat',
'menyayat-nyayat': 'sayat',
'kesayuan': 'sayu',
'menyayukan': 'sayu',
'sebaran': 'sebar',
'sebarannya': 'sebar',
'penyebar': 'sebar',
'penyebarnya': 'sebar',
'penyebarkan': 'sebar',
'penyebaran': 'sebar',
'menyebar': 'sebar',
'menyebarnya': 'sebar',
'menyebarlah': 'sebar',
'menyebarkan': 'sebar',
'menyebarkannya': 'sebar',
'menyebari': 'sebar',
'menyebaran': 'sebar',
'tersebar': 'sebar',
'tersebarnya': 'sebar',
'tersebarlah': 'sebar',
'tersebarkan': 'sebar',
'tersebari': 'sebar',
'bersebar': 'sebar',
'bersebaran': 'sebar',
'penyebarannya': 'sebar',
'persebaran': 'sebar',
'persebarannya': 'sebar',
'menyebarkanlah': 'sebar',
'tersebar luas': 'sebar luas',
'penyebarluasan': 'sebar luas',
'penyebarluasannya': 'sebar luas',
'menyebarluaskan': 'sebar luas',
'menyebarluaskannya': 'sebar luas',
'menyebat': 'sebat',
'menyebatkan': 'sebat',
'kesebatan': 'sebat',
'penyebatan': 'sebat',
'sebutan': 'sebut',
'sebutannya': 'sebut',
'tersebut': 'sebut',
'tersebutnya': 'sebut',
'tersebutlah': 'sebut',
'tersebutkan': 'sebut',
'tersebuti': 'sebut',
'penyebut': 'sebut',
'penyebutnya': 'sebut',
'penyebutkan': 'sebut',
'penyebutan': 'sebut',
'menyebut': 'sebut',
'menyebutnya': 'sebut',
'menyebutkan': 'sebut',
'menyebutkannya': 'sebut',
'menyebutan': 'sebut',
'menyebutku': 'sebut',
'menyebutmu': 'sebut',
'penyebutannya': 'sebut',
'penyebutanan': 'sebut',
'menyebutkankan': 'sebut',
'menyebutkani': 'sebut',
'bersedih': 'sedih',
'bersedihlah': 'sedih',
'penyedih': 'sedih',
'kesedihan': 'sedih',
'kesedihannya': 'sedih',
'kesedihanlah': 'sedih',
'kesedihanku': 'sedih',
'kesedihanmu': 'sedih',
'menyedihkan': 'sedih',
'menyedihkannya': 'sedih',
'menyedihkanlah': 'sedih',
'tersedih-sedih': 'sedih',
'penyeduh': 'seduh',
'penyeduhan': 'seduh',
'menyeduh': 'seduh',
'menyeduhnya': 'seduh',
'menyeduhkan': 'seduh',
'terseduh-seduh': 'seduh',
'penyegan': 'segan',
'keseganan': 'segan',
'kesegananan': 'segan',
'menyegani': 'segan',
'menyeganinya': 'segan',
'segan-segan': 'segan',
'segan-segannya': 'segan',
'segan-menyegan': 'segan',
'segan-menyegani': 'segan',
'menyejatkan': 'sejat',
'sekaan': 'seka',
'berseka': 'seka',
'menyeka': 'seka',
'menyekanya': 'seka',
'menyekalah': 'seka',
'menyekai': 'seka',
'menyekakan': 'seka',
'peselam': 'selam',
'terselam': 'selam',
'terselami': 'selam',
'menyelam': 'selam',
'menyelamnya': 'selam',
'menyelamlah': 'selam',
'menyelamkan': 'selam',
'menyelami': 'selam',
'berselam': 'selam',
'penyelam': 'selam',
'penyelamnya': 'selam',
'penyelaman': 'selam',
'menyelaminya': 'selam',
'penyelamannya': 'selam',
'penyelamanan': 'selam',
'menyelar': 'selar',
'menyelarkan': 'selar',
'selenggaraan': 'selenggara',
'menyelenggara': 'selenggara',
'menyelenggarakan': 'selenggara',
'menyelenggarakannya': 'selenggara',
'menyelenggaraan': 'selenggara',
'penyelenggara': 'selenggara',
'penyelenggaranya': 'selenggara',
'penyelenggaralah': 'selenggara',
'penyelenggarakan': 'selenggara',
'penyelenggarai': 'selenggara',
'penyelenggaraan': 'selenggara',
'terselenggara': 'selenggara',
'terselenggaranya': 'selenggara',
'terselenggaralah': 'selenggara',
'terselenggarakan': 'selenggara',
'terselenggarakannya': 'selenggara',
'penyelenggaraannya': 'selenggara',
'selesaian': 'selesai',
'keselesaian': 'selesai',
'penyelesaian': 'selesai',
'penyelesaiannya': 'selesai',
'penyelesaianlah': 'selesai',
'penyelesaianan': 'selesai',
'menyelesaikan': 'selesai',
'menyelesaikannya': 'selesai',
'terselesaikan': 'selesai',
'terselesaikannya': 'selesai',
'menyeleweng': 'seleweng',
'menyelewengnya': 'seleweng',
'menyelewengkan': 'seleweng',
'menyelewengkannya': 'seleweng',
'menyelewengi': 'seleweng',
'menyelewengan': 'seleweng',
'penyeleweng': 'seleweng',
'penyelewengkan': 'seleweng',
'penyelewengan': 'seleweng',
'penyelewengannya': 'seleweng',
'penyelidik': 'selidik',
'penyelidiknya': 'selidik',
'penyelidikkan': 'selidik',
'penyelidiki': 'selidik',
'penyelidikan': 'selidik',
'menyelidik': 'selidik',
'menyelidiknya': 'selidik',
'menyelidiki': 'selidik',
'menyelidikan': 'selidik',
'menyelidikinya': 'selidik',
'menyelidikii': 'selidik',
'penyelidikannya': 'selidik',
'berselimut': 'selimut',
'berselimutkan': 'selimut',
'berselimuti': 'selimut',
'menyelimuti': 'selimut',
'menyelimutinya': 'selimut',
'menyelimutiku': 'selimut',
'menyelimutimu': 'selimut',
'menyelimutkan': 'selimut',
'penyelinap': 'selinap',
'penyelinapan': 'selinap',
'menyelinap': 'selinap',
'menyelinapnya': 'selinap',
'menyelinaplah': 'selinap',
'menyelinapkan': 'selinap',
'menyelinapkannya': 'selinap',
'penyelinapannya': 'selinap',
'selipan': 'selip',
'menyelip': 'selip',
'menyelipnya': 'selip',
'menyelipkan': 'selip',
'menyelipkannya': 'selip',
'menyelipi': 'selip',
'terselip': 'selip',
'terselipnya': 'selip',
'terseliplah': 'selip',
'terselipkan': 'selip',
'terselipi': 'selip',
'terselip': 'selip',
'menyelisik': 'selisik',
'penyelisikan': 'selisik',
'terselit': 'selit',
'menyelitkan': 'selit',
'berselit sepit': 'selit',
'berselit-selit': 'selit',
'berselubung': 'selubung',
'berselubungkan': 'selubung',
'menyelubung': 'selubung',
'menyelubungkan': 'selubung',
'menyelubungi': 'selubung',
'penyelubung': 'selubung',
'penyelubungan': 'selubung',
'terselubung': 'selubung',
'terselubungnya': 'selubung',
'terselubungi': 'selubung',
'menyelubunginya': 'selubung',
'seludupan': 'seludup',
'penyeludup': 'seludup',
'penyeludupan': 'seludup',
'menyeludup': 'seludup',
'menyeludupkan': 'seludup',
'menyeludupkannya': 'seludup',
'berseluk': 'seluk',
'menyeluk': 'seluk',
'seluk-semeluk': 'seluk',
'memperselukkan': 'seluk',
'semahan': 'semah',
'menyemah': 'semah',
'penyemah': 'semah',
'semah-semah': 'semah',
'menyemahkan': 'semah',
'semaian': 'semai',
'tersemai': 'semai',
'tersemainya': 'semai',
'menyemai': 'semai',
'menyemaikan': 'semai',
'pesemaian': 'semai',
'penyemaian': 'semai',
'penyemaiannya': 'semai',
'persemaian': 'semai',
'persemaiannya': 'semai',
'mempersemaikan': 'semai',
'sematan': 'semat',
'menyemat': 'semat',
'menyematkan': 'semat',
'menyematkannya': 'semat',
'menyemati': 'semat',
'tersemat': 'semat',
'tersematnya': 'semat',
'tersematkan': 'semat',
'tersemati': 'semat',
'penyemat': 'semat',
'penyematan': 'semat',
'penyematannya': 'semat',
'sembelihan': 'sembelih',
'penyembelih': 'sembelih',
'penyembelihan': 'sembelih',
'menyembelih': 'sembelih',
'menyembelihnya': 'sembelih',
'penyembelihannya': 'sembelih',
'penyembuh': 'sembuh',
'penyembuhnya': 'sembuh',
'penyembuhkan': 'sembuh',
'penyembuhan': 'sembuh',
'kesembuhan': 'sembuh',
'kesembuhannya': 'sembuh',
'kesembuhanku': 'sembuh',
'penyembuhannya': 'sembuh',
'penyembuhanku': 'sembuh',
'penyembuhanmu': 'sembuh',
'menyembuhkan': 'sembuh',
'menyembuhkannya': 'sembuh',
'menyembuhkanku': 'sembuh',
'menyembuhkanmu': 'sembuh',
'bersenang': 'senang',
'kesenangan': 'senang',
'kesenangannya': 'senang',
'kesenanganku': 'senang',
'kesenanganmu': 'senang',
'menyenangi': 'senang',
'menyenanginya': 'senang',
'menyenangkan': 'senang',
'menyenangkannya': 'senang',
'mempersenang': 'senang',
'mempersenangkan': 'senang',
'bersenang-senang': 'senang',
'bersenang-senangnya': 'senang',
'bersenang-senanglah': 'senang',
'bersenang-senangkan': 'senang',
'menyenaraikan': 'senarai',
'sendalan': 'sendal',
'tersendal': 'sendal',
'menyendal': 'sendal',
'kesendalan': 'sendal',
'menyendalkan': 'sendal',
'bersendeng': 'sendeng',
'menyendeng': 'sendeng',
'menyendengkan': 'sendeng',
'bersendengan': 'sendeng',
'tersendeng-sendeng': 'sendeng',
'sengauan': 'sengau',
'menyengau': 'sengau',
'penyengauan': 'sengau',
'menyengaukan': 'sengau',
'sengau-sengauan': 'sengau',
'tersenget': 'senget',
'menyenget': 'senget',
'menyengetkan': 'senget',
'sentakan': 'sentak',
'menyentak': 'sentak',
'menyentaknya': 'sentak',
'menyentakkan': 'sentak',
'menyentakan': 'sentak',
'tersentak': 'sentak',
'tersentaklah': 'sentak',
'menyentak-nyentak': 'sentak',
'sepakan': 'sepak',
'sepakannya': 'sepak',
'sepakanku': 'sepak',
'penyepak': 'sepak',
'menyepak': 'sepak',
'menyepaknya': 'sepak',
'menyepakkan': 'sepak',
'menyepaki': 'sepak',
'penyepakan': 'sepak',
'bersepak-sepakan': 'sepak',
'menyepak-nyepakkan': 'sepak',
'keseraman': 'seram',
'keseramannya': 'seram',
'menyeramkan': 'seram',
'menyeramkannya': 'seram',
'menyeranah': 'seranah',
'serangan': 'serang',
'serangannya': 'serang',
'serangankan': 'serang',
'seranganan': 'serang',
'seranganmu': 'serang',
'menyerang': 'serang',
'menyerangnya': 'serang',
'menyeranglah': 'serang',
'menyerangkan': 'serang',
'menyerangan': 'serang',
'menyerangku': 'serang',
'menyerangmu': 'serang',
'penyerang': 'serang',
'penyerangnya': 'serang',
'penyeranglah': 'serang',
'penyerangkan': 'serang',
'penyerangan': 'serang',
'penyerangmu': 'serang',
'berserang': 'serang',
'berserangan': 'serang',
'terserang': 'serang',
'terserangnya': 'serang',
'penyerangannya': 'serang',
'penyeranganlah': 'serang',
'serang-serangan': 'serang',
'serang-serangannya': 'serang',
'serang-menyerang': 'serang',
'teserbu': 'serbu',
'serbuan': 'serbu',
'serbuannya': 'serbu',
'menyerbu': 'serbu',
'menyerbunya': 'serbu',
'penyerbuan': 'serbu',
'penyerbuannya': 'serbu',
'menyerbukan': 'serbu',
'terseret': 'seret',
'terseretnya': 'seret',
'terseretlah': 'seret',
'penyeret': 'seret',
'penyeretan': 'seret',
'menyeret': 'seret',
'menyeretnya': 'seret',
'menyeretkan': 'seret',
'menyeretku': 'seret',
'menyeret-nyeret': 'seret',
'menyerkap': 'serkap',
'menyerkapi': 'serkap',
'penyerkapan': 'serkap',
'teserlah': 'serlah',
'menyerlah': 'serlah',
'penyesah': 'sesah',
'penyesahan': 'sesah',
'bersesah': 'sesah',
'menyesah': 'sesah',
'menyesahkan': 'sesah',
'sesalan': 'sesal',
'bersesal': 'sesal',
'menyesal': 'sesal',
'menyesalnya': 'sesal',
'menyesallah': 'sesal',
'menyesalkan': 'sesal',
'menyesalkannya': 'sesal',
'menyesali': 'sesal',
'menyesalinya': 'sesal',
'penyesalan': 'sesal',
'penyesalannya': 'sesal',
'penyesalanlah': 'sesal',
'penyesalanku': 'sesal',
'bersesalan': 'sesal',
'menyesalkanlah': 'sesal',
'sesal-menyesali': 'sesal',
'penyetir': 'setir',
'penyetiran': 'setir',
'menyetir': 'setir',
'menyetirnya': 'setir',
'menyetiri': 'setir',
'sewaan': 'sewa',
'sewaannya': 'sewa',
'menyewa': 'sewa',
'menyewanya': 'sewa',
'menyewakan': 'sewa',
'menyewakannya': 'sewa',
'menyewaan': 'sewa',
'menyewaku': 'sewa',
'penyewa': 'sewa',
'penyewanya': 'sewa',
'penyewaan': 'sewa',
'penyewaannya': 'sewa',
'mempersewakan': 'sewa',
'bersiap': 'siap',
'bersiapnya': 'siap',
'bersiaplah': 'siap',
'bersiapkan': 'siap',
'bersiapan': 'siap',
'penyiapan': 'siap',
'penyiapannya': 'siap',
'persiapan': 'siap',
'persiapannya': 'siap',
'persiapanlah': 'siap',
'persiapankan': 'siap',
'persiapanan': 'siap',
'persiapanku': 'siap',
'persiapanmu': 'siap',
'menyiapkan': 'siap',
'menyiapkannya': 'siap',
'menyiapkanlah': 'siap',
'menyiapkanku': 'siap',
'bersiap-siap': 'siap',
'bersiap-siaplah': 'siap',
'bersiap-siapkan': 'siap',
'mempersiapkan': 'siap',
'mempersiapkannya': 'siap',
'mempersiapkanan': 'siap',
'siaran': 'siar',
'siarannya': 'siar',
'siarankan': 'siar',
'siaranku': 'siar',
'pesiar': 'siar',
'pesiarnya': 'siar',
'penyiar': 'siar',
'penyiarnya': 'siar',
'penyiaran': 'siar',
'tersiar': 'siar',
'tersiarnya': 'siar',
'tersiarlah': 'siar',
'tersiarkan': 'siar',
'tersiarkannya': 'siar',
'menyiar': 'siar',
'menyiarkan': 'siar',
'menyiarkannya': 'siar',
'menyiaran': 'siar',
'bersiar': 'siar',
'bersiaran': 'siar',
'penyiarannya': 'siar',
'persiaran': 'siar',
'bersiar-siar': 'siar',
'menyiasat': 'siasat',
'menyiasatkan': 'siasat',
'menyiasati': 'siasat',
'bersiasat': 'siasat',
'menyiasatinya': 'siasat',
'menyidai': 'sidai',
'menyidaikan': 'sidai',
'menyigung': 'sigung',
'tersihir': 'sihir',
'menyihir': 'sihir',
'menyihirnya': 'sihir',
'menyihiri': 'sihir',
'menyihirkan': 'sihir',
'siksaan': 'siksa',
'siksaannya': 'siksa',
'penyiksa': 'siksa',
'penyiksanya': 'siksa',
'penyiksaan': 'siksa',
'penyiksaku': 'siksa',
'tersiksa': 'siksa',
'tersiksanya': 'siksa',
'menyiksa': 'siksa',
'menyiksanya': 'siksa',
'menyiksalah': 'siksa',
'menyiksakan': 'siksa',
'menyiksaan': 'siksa',
'menyiksaku': 'siksa',
'menyiksamu': 'siksa',
'menyiksai': 'siksa',
'penyiksaannya': 'siksa',
'ketersiksaan': 'siksa',
'bersiku': 'siku',
'menyiku': 'siku',
'menyikunya': 'siku',
'siku-siku': 'siku',
'siku-sikunya': 'siku',
'menyikukan': 'siku',
'tersilau': 'silau',
'tersilaukan': 'silau',
'menyilau': 'silau',
'menyilaukan': 'silau',
'kesilauan': 'silau',
'menyimbah': 'simbah',
'bersimbah': 'simbah',
'bersimbahkan': 'simbah',
'tersimbah': 'simbah',
'menyimbahkan': 'simbah',
'simpanan': 'simpan',
'simpanannya': 'simpan',
'simpananmu': 'simpan',
'menyimpan': 'simpan',
'menyimpannya': 'simpan',
'menyimpankan': 'simpan',
'menyimpanan': 'simpan',
'bersimpan': 'simpan',
'penyimpan': 'simpan',
'penyimpannya': 'simpan',
'penyimpanan': 'simpan',
'tersimpan': 'simpan',
'tersimpannya': 'simpan',
'menyimpani': 'simpan',
'penyimpanannya': 'simpan',
'penyimpananan': 'simpan',
'sindiran': 'sindir',
'sindirannya': 'sindir',
'penyindir': 'sindir',
'penyindiran': 'sindir',
'menyindir': 'sindir',
'menyindirnya': 'sindir',
'menyindirkan': 'sindir',
'menyindiri': 'sindir',
'tersindir': 'sindir',
'tersindiri': 'sindir',
'sindir-menyindir': 'sindir',
'menyinggung': 'singgung',
'menyinggungnya': 'singgung',
'menyinggungkan': 'singgung',
'menyinggungku': 'singgung',
'tersinggung': 'singgung',
'tersinggungnya': 'singgung',
'persinggungan': 'singgung',
'persinggungannya': 'singgung',
'bersinggungan': 'singgung',
'menyingkir': 'singkir',
'menyingkirnya': 'singkir',
'menyingkirlah': 'singkir',
'menyingkirkan': 'singkir',
'menyingkirkannya': 'singkir',
'menyingkiran': 'singkir',
'tersingkir': 'singkir',
'tersingkirnya': 'singkir',
'tersingkirkan': 'singkir',
'tersingkirkannya': 'singkir',
'tersingkiri': 'singkir',
'penyingkir': 'singkir',
'penyingkiran': 'singkir',
'menyingkiri': 'singkir',
'menyingkirikan': 'singkir',
'penyingkirannya': 'singkir',
'menyingkirkanku': 'singkir',
'menyingkirkanmu': 'singkir',
'tersingsing': 'singsing',
'menyingsing': 'singsing',
'menyingsingkan': 'singsing',
'disisih': 'sisih',
'disisihkan': 'sisih',
'disisihkannya': 'sisih',
'tersisih': 'sisih',
'tersisihnya': 'sisih',
'tersisihkan': 'sisih',
'tersisihkannya': 'sisih',
'tersisihan': 'sisih',
'menyisih': 'sisih',
'menyisihkan': 'sisih',
'menyisihkannya': 'sisih',
'menyisihan': 'sisih',
'penyisihan': 'sisih',
'penyisihannya': 'sisih',
'menyisihkankan': 'sisih',
'ketersisihan': 'sisih',
'sisipan': 'sisip',
'tersisip': 'sisip',
'tersisipnya': 'sisip',
'tersisipkan': 'sisip',
'tersisipi': 'sisip',
'menyisip': 'sisip',
'menyisipkan': 'sisip',
'menyisipkannya': 'sisip',
'menyisipi': 'sisip',
'penyisip': 'sisip',
'penyisipan': 'sisip',
'kesisipan': 'sisip',
'mempersisipkan': 'sisip',
'sogokan': 'sogok',
'sogokannya': 'sogok',
'penyogok': 'sogok',
'penyogokkan': 'sogok',
'penyogokan': 'sogok',
'menyogok': 'sogok',
'menyogoknya': 'sogok',
'sokongan': 'sokong',
'sokongannya': 'sokong',
'sokonganku': 'sokong',
'menyokong': 'sokong',
'menyokongnya': 'sokong',
'penyokong': 'sokong',
'penyokongnya': 'sokong',
'penyokongan': 'sokong',
'menyokongkan': 'sokong',
'menyompoh': 'sompoh',
'sorotan': 'sorot',
'sorotannya': 'sorot',
'menyorot': 'sorot',
'menyorotnya': 'sorot',
'menyorotlah': 'sorot',
'menyorotkan': 'sorot',
'menyorotkannya': 'sorot',
'menyoroti': 'sorot',
'penyorot': 'sorot',
'penyoroti': 'sorot',
'penyorotan': 'sorot',
'menyorotinya': 'sorot',
'suapan': 'suap',
'suapannya': 'suap',
'sesuap': 'suap',
'menyuap': 'suap',
'menyuapnya': 'suap',
'menyuapkan': 'suap',
'menyuapkannya': 'suap',
'menyuapi': 'suap',
'menyuapan': 'suap',
'penyuap': 'suap',
'penyuapnya': 'suap',
'penyuapan': 'suap',
'bersuap': 'suap',
'bersuapan': 'suap',
'menyuapinya': 'suap',
'penyuapannya': 'suap',
'menyuapkankan': 'suap',
'bersuap-suapan': 'suap',
'sesukat': 'sukat',
'sukatan': 'sukat',
'sukatani': 'sukat',
'penyukat': 'sukat',
'menyukat': 'sukat',
'bersukat': 'sukat',
'penyukatan': 'sukat',
'sulaan': 'sula',
'menyula': 'sula',
'menyulai': 'sula',
'penyula': 'sula',
'penyulai': 'sula',
'penyulaan': 'sula',
'menyulakan': 'sula',
'sulaman': 'sulam',
'sulamannya': 'sulam',
'sulamani': 'sulam',
'menyulam': 'sulam',
'menyulamnya': 'sulam',
'menyulamkan': 'sulam',
'bersulam': 'sulam',
'penyulaman': 'sulam',
'penyulamannya': 'sulam',
'pesulap': 'sulap',
'pesulapnya': 'sulap',
'sulapan': 'sulap',
'menyulap': 'sulap',
'menyulapnya': 'sulap',
'menyulapmu': 'sulap',
'penyulap': 'sulap',
'penyulapan': 'sulap',
'bersulap': 'sulap',
'sulingan': 'suling',
'menyuling': 'suling',
'tersuling': 'suling',
'penyulingan': 'suling',
'penyulingannya': 'suling',
'menyulingkan': 'suling',
'sunatan': 'sunat',
'sunatannya': 'sunat',
'bersunat': 'sunat',
'menyunat': 'sunat',
'menyunatnya': 'sunat',
'menyunatkan': 'sunat',
'menyunati': 'sunat',
'penyunatan': 'sunat',
'menyunatrasulkan': 'sunat rasul',
'bersundal': 'sundal',
'menyundal': 'sundal',
'persundalan': 'sundal',
'sungkupan': 'sungkup',
'penyungkup': 'sungkup',
'menyungkup': 'sungkup',
'tersungkup': 'sungkup',
'bersungkup': 'sungkup',
'menyungkupi': 'sungkup',
'menyungkupkan': 'sungkup',
'tersungkur': 'sungkur',
'tersungkurnya': 'sungkur',
'menyungkur': 'sungkur',
'menyungkurkan': 'sungkur',
'suntikan': 'suntik',
'suntikannya': 'suntik',
'menyuntik': 'suntik',
'menyuntiknya': 'suntik',
'menyuntikkan': 'suntik',
'menyuntikkannya': 'suntik',
'menyuntikan': 'suntik',
'menyuntikku': 'suntik',
'penyuntikan': 'suntik',
'penyuntikannya': 'suntik',
'suntingan': 'sunting',
'suntingannya': 'sunting',
'menyunting': 'sunting',
'menyuntingnya': 'sunting',
'tersunting': 'sunting',
'bersunting': 'sunting',
'penyunting': 'sunting',
'penyuntingan': 'sunting',
'penyuntingannya': 'sunting',
'menyuntingkan': 'sunting',
'bersuntingkan': 'sunting',
'mempersunting': 'sunting',
'mempersuntingnya': 'sunting',
'sunting-menyunting': 'sunting',
'pesuruh': 'suruh',
'pesuruhnya': 'suruh',
'pesuruhan': 'suruh',
'pesuruhmu': 'suruh',
'suruhan': 'suruh',
'suruhannya': 'suruh',
'penyuruh': 'suruh',
'penyuruhnya': 'suruh',
'menyuruh': 'suruh',
'menyuruhnya': 'suruh',
'menyuruhkan': 'suruh',
'menyuruhku': 'suruh',
'menyuruhmu': 'suruh',
'suruh-suruhan': 'suruh',
'susukan': 'susuk',
'susukanlah': 'susuk',
'bersusuk': 'susuk',
'menyusuk': 'susuk',
'menyusukan': 'susuk',
'bersusuk-susuk': 'susuk',
'bersusuk-susukan': 'susuk',
'susulan': 'susul',
'susulannya': 'susul',
'tersusul': 'susul',
'penyusul': 'susul',
'penyusulan': 'susul',
'menyusul': 'susul',
'menyusulnya': 'susul',
'menyusullah': 'susul',
'menyusulkan': 'susul',
'menyusulkannya': 'susul',
'menyusuli': 'susul',
'menyusulku': 'susul',
'menyusulmu': 'susul',
'menyusulinya': 'susul',
'susul-menyusul': 'susul',
'susunan': 'susun',
'susunannya': 'susun',
'susunanlah': 'susun',
'susunanan': 'susun',
'menyusun': 'susun',
'menyusunnya': 'susun',
'menyusunkan': 'susun',
'menyusunan': 'susun',
'penyusun': 'susun',
'penyusunnya': 'susun',
'penyusunan': 'susun',
'bersusun': 'susun',
'bersusunan': 'susun',
'tersusun': 'susun',
'tersusunnya': 'susun',
'tersusunlah': 'susun',
'penyusunannya': 'susun',
'penyusunanan': 'susun',
'susupan': 'susup',
'menyusup': 'susup',
'menyusupnya': 'susup',
'menyusuplah': 'susup',
'menyusupkan': 'susup',
'menyusupi': 'susup',
'penyusup': 'susup',
'penyusupnya': 'susup',
'penyusupan': 'susup',
'kesusupan': 'susup',
'penyusupannya': 'susup',
'susuran': 'susur',
'menyusur': 'susur',
'menyusurnya': 'susur',
'menyusuri': 'susur',
'penyusur': 'susur',
'penyusuran': 'susur',
'menyusurinya': 'susur',
'penyusur bayar': 'susur',
'menyusut': 'susut',
'menyusutnya': 'susut',
'menyusutlah': 'susut',
'menyusutkan': 'susut',
'menyusutan': 'susut',
'menyusuti': 'susut',
'penyusutan': 'susut',
'penyusutannya': 'susut',
'meraban': 'raban',
'meracau': 'racau',
'meradang': 'radang',
'meradangnya': 'radang',
'meradangkan': 'radang',
'meradangan': 'radang',
'peradang': 'radang',
'peradangan': 'radang',
'peradangannya': 'radang',
'peradanganlah': 'radang',
'seragam': 'ragam',
'seragamnya': 'ragam',
'seragamkan': 'ragam',
'seragaman': 'ragam',
'seragamku': 'ragam',
'seragammu': 'ragam',
'meragam': 'ragam',
'meragamkan': 'ragam',
'keragaman': 'ragam',
'keragamannya': 'ragam',
'keragamanan': 'ragam',
'beragam-ragam': 'ragam',
'seragam sebahu': 'ragam',
'meragut': 'ragut',
'perajut': 'rajut',
'perajutan': 'rajut',
'rajutan': 'rajut',
'rajutannya': 'rajut',
'terajut': 'rajut',
'merajut': 'rajut',
'merajutnya': 'rajut',
'merajutkan': 'rajut',
'merajutkannya': 'rajut',
'merak hati': 'merak',
'merak simpin': 'merak',
'ramalan': 'ramal',
'ramalannya': 'ramal',
'ramalanmu': 'ramal',
'meramal': 'ramal',
'meramalnya': 'ramal',
'meramalkan': 'ramal',
'meramalkannya': 'ramal',
'terambah': 'rambah',
'merambah': 'rambah',
'merambahnya': 'rambah',
'merambahkan': 'rambah',
'merambahi': 'rambah',
'perambah': 'rambah',
'perambahnya': 'rambah',
'perambahan': 'rambah',
'rambahan': 'rambah',
'rambahannya': 'rambah',
'perambahannya': 'rambah',
'merambat': 'rambat',
'merambatnya': 'rambat',
'merambatlah': 'rambat',
'merambatkan': 'rambat',
'merambatkannya': 'rambat',
'merambati': 'rambat',
'rambatan': 'rambat',
'rambatannya': 'rambat',
'perambat': 'rambat',
'perambatnya': 'rambat',
'perambatan': 'rambat',
'perambatannya': 'rambat',
'perampas': 'rampas',
'perampasan': 'rampas',
'rampasan': 'rampas',
'rampasannya': 'rampas',
'merampas': 'rampas',
'merampasnya': 'rampas',
'merampasan': 'rampas',
'merampasi': 'rampas',
'perampasannya': 'rampas',
'merancap': 'rancap',
'meranduk': 'randuk',
'meranggas': 'ranggas',
'meranggasnya': 'ranggas',
'meranggaskan': 'ranggas',
'rangkakan': 'rangkak',
'merangkak': 'rangkak',
'merangkaknya': 'rangkak',
'merangkaklah': 'rangkak',
'merangkaki': 'rangkak',
'perangkakan': 'rangkak',
'merangkakkan': 'rangkak',
'merangkak-rangkak': 'rangkak',
'rangkulan': 'rangkul',
'rangkulannya': 'rangkul',
'merangkul': 'rangkul',
'merangkulnya': 'rangkul',
'merangkulkan': 'rangkul',
'merangkuli': 'rangkul',
'merangkulku': 'rangkul',
'berangkulan': 'rangkul',
'berangkulanlah': 'rangkul',
'rangkul-merangkul': 'rangkul',
'rangkuman': 'rangkum',
'rangkumannya': 'rangkum',
'merangkum': 'rangkum',
'merangkumnya': 'rangkum',
'merangkumkan': 'rangkum',
'merangkumkannya': 'rangkum',
'merangkuman': 'rangkum',
'merangkup': 'rangkup',
'terangkup': 'rangkup',
'rantaian': 'rantai',
'terantai': 'rantai',
'merantai': 'rantai',
'merantainya': 'rantai',
'merantaikan': 'rantai',
'berantai': 'rantai',
'berantainya': 'rantai',
'berantailah': 'rantai',
'berantai-rantai': 'rantai',
'rapatan': 'rapat',
'berapat': 'rapat',
'merapat': 'rapat',
'merapatnya': 'rapat',
'merapatlah': 'rapat',
'merapatkan': 'rapat',
'merapatkannya': 'rapat',
'merapati': 'rapat',
'perapat': 'rapat',
'perapatan': 'rapat',
'kerapatan': 'rapat',
'kerapatannya': 'rapat',
'kerapatanan': 'rapat',
'memperapat': 'rapat',
'perasaian': 'rasai',
'merasaikan': 'rasai',
'merasuk': 'rasuk',
'merasuknya': 'rasuk',
'merasuki': 'rasuk',
'kerasukan': 'rasuk',
'merata': 'rata',
'meratanya': 'rata',
'meratalah': 'rata',
'meratakan': 'rata',
'meratakannya': 'rata',
'meratai': 'rata',
'merataan': 'rata',
'serata': 'rata',
'rata-rata': 'rata',
'rata-ratanya': 'rata',
'rata-ratalah': 'rata',
'rata-ratakan': 'rata',
'rata-ratai': 'rata',
'pemerataan': 'rata',
'pemerataannya': 'rata',
'memeratakan': 'rata',
'menyeratakan': 'rata',
'merata-ratakan': 'rata',
'ratapan': 'ratap',
'ratapannya': 'ratap',
'ratapani': 'ratap',
'meratap': 'ratap',
'meratapi': 'ratap',
'meratapinya': 'ratap',
'raungan': 'raung',
'raungannya': 'raung',
'meraung': 'raung',
'meraungkan': 'raung',
'meraungi': 'raung',
'meraung-raung': 'raung',
'meraung-raungnya': 'raung',
'meraung-raungkan': 'raung',
'peraup': 'raup',
'raupan': 'raup',
'seraup': 'raup',
'meraup': 'raup',
'meraupnya': 'raup',
'meraupkannya': 'raup',
'merawat': 'rawat',
'merawatnya': 'rawat',
'merawatkan': 'rawat',
'merawatkannya': 'rawat',
'merawati': 'rawat',
'merawatan': 'rawat',
'merawatku': 'rawat',
'merawatmu': 'rawat',
'terawat': 'rawat',
'terawatnya': 'rawat',
'rawatan': 'rawat',
'perawat': 'rawat',
'perawatnya': 'rawat',
'perawatlah': 'rawat',
'perawati': 'rawat',
'perawatan': 'rawat',
'perawatku': 'rawat',
'perawatannya': 'rawat',
'perawatanan': 'rawat',
'perawatanku': 'rawat',
'keperawatan': 'rawat',
'keperawatannya': 'rawat',
'perayaan': 'raya',
'perayaannya': 'raya',
'perayaanan': 'raya',
'merayakan': 'raya',
'merayakannya': 'raya',
'merayan': 'rayan',
'merayani': 'rayan',
'terayan-rayan': 'rayan',
'merayau': 'rayau',
'merayau-rayau': 'rayau',
'rayuan': 'rayu',
'rayuannya': 'rayu',
'rayuanmu': 'rayu',
'perayu': 'rayu',
'perayunya': 'rayu',
'merayu': 'rayu',
'merayunya': 'rayu',
'merayuku': 'rayu',
'merayukan': 'rayu',
'merayu-rayu': 'rayu',
'kemercusuaran': 'mercusuar',
'rebahan': 'rebah',
'merebah': 'rebah',
'merebahnya': 'rebah',
'merebahkan': 'rebah',
'merebahkannya': 'rebah',
'rebah-rebah': 'rebah',
'rebah-rebahan': 'rebah',
'merebak': 'rebak',
'merebaknya': 'rebak',
'merebaklah': 'rebak',
'merebakkan': 'rebak',
'merebakan': 'rebak',
'merebu': 'rebu',
'merebus': 'rebus',
'merebusnya': 'rebus',
'rebusan': 'rebus',
'rebusannya': 'rebus',
'rebutan': 'rebut',
'rebutannya': 'rebut',
'merebut': 'rebut',
'merebutnya': 'rebut',
'merebutkan': 'rebut',
'terebut': 'rebut',
'terebutnya': 'rebut',
'berebut': 'rebut',
'berebutnya': 'rebut',
'berebutlah': 'rebut',
'berebutkan': 'rebut',
'berebutan': 'rebut',
'perebutan': 'rebut',
'perebutannya': 'rebut',
'berebut-rebut': 'rebut',
'memperebutkan': 'rebut',
'memperebutkannya': 'rebut',
'memperebutkankan': 'rebut',
'berebut-rebutan': 'rebut',
'bereda': 'reda',
'beredanya': 'reda',
'mereda': 'reda',
'meredanya': 'reda',
'meredakan': 'reda',
'meredakannya': 'reda',
'meredai': 'reda',
'peredaan': 'reda',
'peredaannya': 'reda',
'keredaan': 'reda',
'redaman': 'redam',
'redamannya': 'redam',
'meredam': 'redam',
'meredamnya': 'redam',
'meredamkan': 'redam',
'peredam': 'redam',
'peredamnya': 'redam',
'peredaman': 'redam',
'peredamannya': 'redam',
'redam-redam': 'redam',
'bermerek': 'merek',
'bermereknya': 'merek',
'merekanya': 'reka',
'merekalah': 'reka',
'merekakan': 'reka',
'merekai': 'reka',
'rekaan': 'reka',
'rekaannya': 'reka',
'reka-reka': 'reka',
'reka-rekaan': 'reka',
'mereka-reka': 'reka',
'merekah': 'rekah',
'merekahnya': 'rekah',
'merekahlah': 'rekah',
'merekahkan': 'rekah',
'perekat': 'rekat',
'perekatnya': 'rekat',
'perekatkan': 'rekat',
'perekatan': 'rekat',
'merekat': 'rekat',
'merekatnya': 'rekat',
'merekatkan': 'rekat',
'merekatkannya': 'rekat',
'serela': 'rela',
'serelanya': 'rela',
'merelai': 'relai',
'merelainya': 'relai',
'kerelaan': 'rela',
'kerelaannya': 'rela',
'merelakan': 'rela',
'merelakannya': 'rela',
'merelakanku': 'rela',
'merelap': 'relap',
'merelap-relap': 'relap',
'merem-merem': 'merem',
'memeremkan': 'merem',
'meremang': 'remang',
'meremangkan': 'remang',
'keremangan': 'remang',
'remang-remang': 'remang',
'remang-remangnya': 'remang',
'merembes': 'rembes',
'merembesnya': 'rembes',
'merembeskan': 'rembes',
'merembesi': 'rembes',
'perembesan': 'rembes',
'perembesannya': 'rembes',
'merempuh': 'rempuh',
'perencana': 'rencana',
'perencananya': 'rencana',
'perencanakan': 'rencana',
'perencanaan': 'rencana',
'berencana': 'rencana',
'berencananya': 'rencana',
'berencanalah': 'rencana',
'berencanakan': 'rencana',
'merencana': 'rencana',
'merencanakan': 'rencana',
'merencanakannya': 'rencana',
'merencanaan': 'rencana',
'perencanaannya': 'rencana',
'perencanaanku': 'rencana',
'perencanaanmu': 'rencana',
'merencanakankan': 'rencana',
'terendam': 'rendam',
'terendamnya': 'rendam',
'rendaman': 'rendam',
'rendamannya': 'rendam',
'berendam': 'rendam',
'berendamnya': 'rendam',
'berendamlah': 'rendam',
'merendam': 'rendam',
'merendamnya': 'rendam',
'merendamkan': 'rendam',
'merendami': 'rendam',
'perendaman': 'rendam',
'merengek': 'rengek',
'merengeki': 'rengek',
'merengek-rengek': 'rengek',
'merenggut': 'renggut',
'merenggutnya': 'renggut',
'merenggutku': 'renggut',
'merengus': 'rengus',
'perengus': 'rengus',
'rentangan': 'rentang',
'rentangannya': 'rentang',
'merentang': 'rentang',
'merentangkan': 'rentang',
'merentangan': 'rentang',
'terentang': 'rentang',
'serentang': 'rentang',
'merentangi': 'rentang',
'renungan': 'renung',
'renungannya': 'renung',
'merenung': 'renung',
'merenunglah': 'renung',
'merenungkan': 'renung',
'merenungkannya': 'renung',
'merenungi': 'renung',
'merenunginya': 'renung',
'perenungan': 'renung',
'perenungannya': 'renung',
'merepes': 'repes',
'resapan': 'resap',
'resapannya': 'resap',
'teresap': 'resap',
'meresap': 'resap',
'meresapnya': 'resap',
'meresapkan': 'resap',
'meresapi': 'resap',
'meresapinya': 'resap',
'peresapan': 'resap',
'merestui': 'restu',
'merestuinya': 'restu',
'meretak': 'retak',
'meretaknya': 'retak',
'meretakkan': 'retak',
'meretakkannya': 'retak',
'meretakan': 'retak',
'retakan': 'retak',
'retakannya': 'retak',
'peretakan': 'retak',
'keretakan': 'retak',
'keretakannya': 'retak',
'retak-retak': 'retak',
'merewang': 'rewang',
'bermerger': 'merger',
'meriah': 'riah',
'meriahnya': 'riah',
'meriahlah': 'riah',
'meriahkan': 'riah',
'meriam buluh': 'meriam katak',
'berias': 'rias',
'beriaslah': 'rias',
'beriaskan': 'rias',
'merias': 'rias',
'meriasnya': 'rias',
'meriasi': 'rias',
'riasan': 'rias',
'riasannya': 'rias',
'riasanku': 'rias',
'meringkik': 'ringkik',
'rintihan': 'rintih',
'rintihannya': 'rintih',
'merintih': 'rintih',
'perintis': 'rintis',
'perintisnya': 'rintis',
'perintisi': 'rintis',
'perintisan': 'rintis',
'merintis': 'rintis',
'merintisnya': 'rintis',
'rintisan': 'rintis',
'rintisannya': 'rintis',
'keperintisan': 'rintis',
'perobohan': 'roboh',
'perobohannya': 'roboh',
'merobohkan': 'roboh',
'merobohkannya': 'roboh',
'robohan': 'roboh',
'kerobohan': 'roboh',
'merodok': 'rodok',
'perokok': 'rokok',
'perokoknya': 'rokok',
'perokoklah': 'rokok',
'merokok': 'rokok',
'merokoknya': 'rokok',
'merokoklah': 'rokok',
'merokoknyalah': 'rokok',
'perompak': 'rompak',
'perompaknya': 'rompak',
'perompakkan': 'rompak',
'perompakan': 'rompak',
'merompak': 'rompak',
'merompaknya': 'rompak',
'peronda': 'ronda',
'perondaan': 'ronda',
'meronda': 'ronda',
'merondai': 'ronda',
'merosot': 'rosot',
'merosotnya': 'rosot',
'merosotlah': 'rosot',
'merosotkan': 'rosot',
'merosotan': 'rosot',
'kemerosotan': 'rosot',
'kemerosotannya': 'rosot',
'merotan': 'rotan',
'perotan': 'rotan',
'berotan': 'rotan',
'rujukan': 'rujuk',
'rujukannya': 'rujuk',
'rujukanlah': 'rujuk',
'merujuk': 'rujuk',
'merujuknya': 'rujuk',
'merujukkan': 'rujuk',
'merujuki': 'rujuk',
'merujukan': 'rujuk',
'perumus': 'rumus',
'perumusnya': 'rumus',
'perumuskan': 'rumus',
'perumusan': 'rumus',
'perumusannya': 'rumus',
'merumuskan': 'rumus',
'merumuskannya': 'rumus',
'merundung': 'rundung',
'merundungnya': 'rundung',
'merundungi': 'rundung',
'seruntai': 'runtai',
'meruntai': 'runtai',
'berusak': 'rusak',
'merusak': 'rusak',
'merusaknya': 'rusak',
'merusaklah': 'rusak',
'merusakkan': 'rusak',
'merusaki': 'rusak',
'merusakan': 'rusak',
'perusak': 'rusak',
'perusaknya': 'rusak',
'perusakkan': 'rusak',
'perusakan': 'rusak',
'merusakinya': 'rusak',
'kerusakan': 'rusak',
'kerusakannya': 'rusak',
'kerusakani': 'rusak',
'kerusakanan': 'rusak',
'perusakannya': 'rusak',
'bermesin': 'mesin',
'bermesinkan': 'mesin',
'permesinan': 'mesin',
'permesinannya': 'mesin',
'meskipun': 'meski',
'meskipunnya': 'meski',
'kemestian': 'mesti',
'memestikan': 'mesti',
'semestinya': 'mesti',
'semestinyalah': 'mesti',
'semestinyakan': 'mesti',
'memesumi': 'mesum',
'bermesum': 'mesum',
'kemesuman': 'mesum',
'permesuman': 'mesum',
'bermetamorfosis': 'metamorfosis',
'meteran': 'meter',
'meterannya': 'meter',
'termeterai': 'meterai',
'bermeterai': 'meterai',
'bermeteraikan': 'meterai',
'memeteraikan': 'meterai',
'kemewahan': 'mewah',
'kemewahannya': 'mewah',
'bermewah-mewah': 'mewah',
'bermewah-mewahan': 'mewah',
'pewaris': 'waris',
'pewarisnya': 'waris',
'pewarisan': 'waris',
'warisan': 'waris',
'warisannya': 'waris',
'warisanku': 'waris',
'warisanmu': 'waris',
'mewarisi': 'waris',
'mewarisinya': 'waris',
'pewarisannya': 'waris',
'kewarisan': 'waris',
'mewariskan': 'waris',
'mewariskannya': 'waris',
'pewarta': 'warta',
'pewartanya': 'warta',
'pewartaan': 'warta',
'pewartaannya': 'warta',
'mewartakan': 'warta',
'mewartakannya': 'warta',
'semiang': 'miang',
'bermigrasi': 'migrasi',
'bermigrasinya': 'migrasi',
'miju-miju': 'miju',
'kemiliteran': 'militer',
'kemiliterannya': 'militer',
'mingguan': 'minggu',
'mingguannya': 'minggu',
'mingguanlah': 'minggu',
'berminggu-minggu': 'minggu',
'bermini': 'mini',
'meminikan': 'mini',
'meminimalkan': 'minimal',
'meminimalkannya': 'minimal',
'meminta': 'minta',
'memintanya': 'minta',
'memintalah': 'minta',
'memintakan': 'minta',
'memintai': 'minta',
'memintaan': 'minta',
'memintaku': 'minta',
'memintamu': 'minta',
'peminta': 'minta',
'pemintanya': 'minta',
'pemintai': 'minta',
'pemintaan': 'minta',
'berminta': 'minta',
'memintainya': 'minta',
'permintaan': 'minta',
'permintaannya': 'minta',
'permintaani': 'minta',
'permintaanku': 'minta',
'permintaanmu': 'minta',
'minta-minta': 'minta',
'minta-mintalah': 'minta',
'meminta-minta': 'minta',
'peminta-minta': 'minta',
'berminta-minta': 'minta',
'bermisai': 'misai',
'semisal': 'misal',
'semisalnya': 'misal',
'memisalkan': 'misal',
'pemitosan': 'mitos',
'memitoskan': 'mitos',
'bermitra': 'mitra',
'bermitranya': 'mitra',
'bermitralah': 'mitra',
'kemitraan': 'mitra',
'kemitraannya': 'mitra',
'kemitrasejajaran': 'mitra sejajar',
'bermobil': 'mobil',
'permobilan': 'mobil',
'memobilisasi': 'mobilisasi',
'memobilisasinya': 'mobilisasi',
'memobilisasikan': 'mobilisasi',
'pemobilisasian': 'mobilisasi',
'pemodal': 'modal',
'pemodalnya': 'modal',
'pemodalan': 'modal',
'memodali': 'modal',
'memodalinya': 'modal',
'bermodal': 'modal',
'bermodalnya': 'modal',
'bermodalkan': 'modal',
'permodalan': 'modal',
'permodalannya': 'modal',
'permodalanan': 'modal',
'memoderatori': 'moderator',
'termodern': 'modern',
'kemodernan': 'modern',
'pemodernan': 'modern',
'memodernkan': 'modern',
'memodernkannya': 'modern',
'memodernisasi': 'modernisasi',
'memodernisasinya': 'modernisasi',
'memodernisasikan': 'modernisasi',
'memodernisasikannya': 'modernisasi',
'pemodifikasi': 'modifikasi',
'pemodifikasian': 'modifikasi',
'memodifikasi': 'modifikasi',
'memodifikasinya': 'modifikasi',
'memodifikasikan': 'modifikasi',
'memodifikasii': 'modifikasi',
'termodifikasi': 'modifikasi',
'semoga': 'moga',
'semoganya': 'moga',
'semogalah': 'moga',
'moga-moga': 'moga',
'pemogok': 'mogok',
'pemogokkan': 'mogok',
'pemogokan': 'mogok',
'pemogokannya': 'mogok',
'pemohon': 'mohon',
'pemohonnya': 'mohon',
'pemohonlah': 'mohon',
'pemohonan': 'mohon',
'bermohon': 'mohon',
'bermohonnya': 'mohon',
'permohonan': 'mohon',
'permohonannya': 'mohon',
'permohonanan': 'mohon',
'permohonanku': 'mohon',
'permohonanmu': 'mohon',
'kemolekan': 'molek',
'kemolekannya': 'molek',
'momongan': 'momong',
'bermoncong': 'moncong',
'memoncongkan': 'moncong',
'bermongkok': 'mongkok',
'memonitor': 'monitor',
'memonitornya': 'monitor',
'memonitori': 'monitor',
'pemonitoran': 'monitor',
'bermonolog': 'monolog',
'termonyong-monyong': 'monyong',
'morak-marik': 'morak',
'bermotif': 'motif',
'bermotifkan': 'motif',
'memuai': 'muai',
'memuaikan': 'muai',
'pemuaian': 'muai',
'bermuara': 'muara',
'bermuaranya': 'muara',
'pemubaziran': 'mubazir',
'kemubaziran': 'mubazir',
'memubazirkan': 'mubazir',
'memubazirkannya': 'mubazir',
'pemuda': 'muda',
'pemudanya': 'muda',
'pemudalah': 'muda',
'pemudaan': 'muda',
'pemudaku': 'muda',
'bermuda': 'muda',
'termuda': 'muda',
'termudanya': 'muda',
'kemudaan': 'muda',
'kemudaannya': 'muda',
'memudakan': 'muda',
'kepemudaan': 'muda',
'kepemudaannya': 'muda',
'mempermuda': 'muda',
'bermuda-muda': 'muda',
'kemuda-mudaan': 'muda',
'pemudah': 'mudah',
'pemudahan': 'mudah',
'semudah': 'mudah',
'semudahnya': 'mudah',
'kemudahan': 'mudah',
'kemudahannya': 'mudah',
'kemudahanlah': 'mudah',
'memudahkan': 'mudah',
'memudahkannya': 'mudah',
'memudahkankan': 'mudah',
'memudahkanku': 'mudah',
'memudahkanmu': 'mudah',
'mempermudah': 'mudah',
'mempermudahnya': 'mudah',
'mempermudahkan': 'mudah',
'mempermudahan': 'mudah',
'mempermudahmu': 'mudah',
'mudah-mudahan': 'mudah',
'mudah-mudahannya': 'mudah',
'mudah-mudahanlah': 'mudah',
'mudah-mudahanan': 'mudah',
'bermudah-mudah': 'mudah',
'memudik': 'mudik',
'memudikkan': 'mudik',
'memudiki': 'mudik',
'pemudik': 'mudik',
'pemudiknya': 'mudik',
'pemudikan': 'mudik',
'semudik': 'mudik',
'bermudun': 'mudun',
'memufakati': 'mufakat',
'bermufakat': 'mufakat',
'kemufakatan': 'mufakat',
'pemufakatan': 'mufakat',
'pemufakatannya': 'mufakat',
'memufakatkan': 'mufakat',
'memufakatkannya': 'mufakat',
'almuhit': 'muhit',
'semujur': 'mujur',
'pemujur': 'mujur',
'kemujuran': 'mujur',
'kemujurannya': 'mujur',
'semujur-mujurnya': 'mujur',
'memukabalahkan': 'mukabalah',
'pemukim': 'mukim',
'pemukimnya': 'mukim',
'pemukiman': 'mukim',
'bermukim': 'mukim',
'bermukimnya': 'mukim',
'bermukimlah': 'mukim',
'bermukiman': 'mukim',
'pemukimannya': 'mukim',
'pemukimanan': 'mukim',
'pemukimanku': 'mukim',
'memukimkan': 'mukim',
'memukimkannya': 'mukim',
'permukiman': 'mukim',
'permukimannya': 'mukim',
'permukimanan': 'mukim',
'kemujizatan': 'mukjizat',
'memula': 'mula',
'memulakan': 'mula',
'memulai': 'mula',
'semula': 'mula',
'semulanya': 'mula',
'semulai': 'mula',
'pemula': 'mula',
'pemulanya': 'mula',
'pemulai': 'mula',
'pemulaan': 'mula',
'bermula': 'mula',
'bermulanya': 'mula',
'bermulai': 'mula',
'bermulaan': 'mula',
'mula-mula': 'mula',
'mula-mulanya': 'mula',
'mula-mulai': 'mula',
'permulaan': 'mula',
'permulaannya': 'mula',
'sebermula': 'mula',
'bermula-mula': 'mula',
'pemulsaan': 'mulsa',
'muluk-muluk': 'muluk',
'muluk-muluklah': 'muluk',
'bermuluk-muluk': 'muluk',
'memulur': 'mulur',
'kemulusan': 'mulus',
'kemulusannya': 'mulus',
'memuluskan': 'mulus',
'memuluskannya': 'mulus',
'memuluskanmu': 'mulus',
'mempermulus': 'mulus',
'bermulut': 'mulut',
'mulut-mulutan': 'mulut',
'bermulut-mulut': 'mulut',
'memumikan': 'mumi',
'bermunajat': 'munajat',
'memuncrat': 'muncrat',
'memuncratkan': 'muncrat',
'kemunculan': 'muncul',
'kemunculannya': 'muncul',
'kemunculanan': 'muncul',
'pemunculan': 'muncul',
'pemunculannya': 'muncul',
'memunculkan': 'muncul',
'memunculkannya': 'muncul',
'bermunculan': 'muncul',
'bermunculannya': 'muncul',
'bermunculanlah': 'muncul',
'pemunduran': 'mundur',
'pemundurannya': 'mundur',
'kemunduran': 'mundur',
'kemundurannya': 'mundur',
'memundurkan': 'mundur',
'memundurkannya': 'mundur',
'memungkari': 'mungkar',
'kemungkaran': 'mungkar',
'memungkiri': 'mungkir',
'memungkirinya': 'mungkir',
'mungmungan': 'mungmung',
'memunjung': 'punjung',
'pemurah': 'murah',
'murahan': 'murah',
'murahannya': 'murah',
'kemurahan': 'murah',
'kemurahannya': 'murah',
'kemurahan-mu': 'murah',
'memurahkan': 'murah',
'mempermurah': 'murah',
'permuseuman': 'museum',
'memuseumkan': 'museum',
'musikan': 'musik',
'musikanan': 'musik',
'pemusik': 'musik',
'pemusiknya': 'musik',
'bermusik': 'musik',
'bermusiknya': 'musik',
'bermusikmu': 'musik',
'memusiki': 'musik',
'memusikkan': 'musik',
'permusikan': 'musik',
'musiman': 'musim',
'musimannya': 'musim',
'bermusim': 'musim',
'kemuskilan': 'muskil',
'memuskilkan': 'muskil',
'pemusnah': 'musnah',
'pemusnahnya': 'musnah',
'pemusnahkan': 'musnah',
'pemusnahan': 'musnah',
'pemusnahannya': 'musnah',
'kemusnahan': 'musnah',
'kemusnahannya': 'musnah',
'memusnahkan': 'musnah',
'memusnahkannya': 'musnah',
'kemustahilan': 'mustahil',
'kemustahilannya': 'mustahil',
'memustahilkan': 'mustahil',
'bermusyawarah': 'musyawarah',
'bermusyawarahlah': 'musyawarah',
'memusyawarahkan': 'musyawarah',
'memusyawarahkannya': 'musyawarah',
'kemusyrikan': 'musyrik',
'memutalaah': 'mutalaah',
'memutalaahkan': 'mutalaah',
'pemutasian': 'mutasi',
'pemutasiannya': 'mutasi',
'memutasikan': 'mutasi',
'memutasikannya': 'mutasi',
'bermuwajahah': 'muwajahah',
'kenabian': 'nabi',
'kenabiannya': 'nabi',
'bernada': 'nada',
'bernadakan': 'nada',
'nada-nadanya': 'nada',
'bernafiri': 'nafiri',
'menafkahi': 'nafkah',
'menafkahinya': 'nafkah',
'menafkahiku': 'nafkah',
'menafkahkan': 'nafkah',
'bernafsi-nafsi': 'nafsi',
'naga-naga': 'naga',
'naga-naganya': 'naga',
'ternahak': 'nahak',
'menaikkelaskan': 'naik kelas',
'menaik': 'naik',
'menaiknya': 'naik',
'menaikkan': 'naik',
'menaikkannya': 'naik',
'menaiki': 'naik',
'menaikan': 'naik',
'menaikinya': 'naik',
'menaikikan': 'naik',
'penaikan': 'naik',
'penaikannya': 'naik',
'penaikanan': 'naik',
'kenaikan': 'naik',
'kenaikannya': 'naik',
'kenaikanlah': 'naik',
'kenaikani': 'naik',
'menaikturunkan': 'naik turun',
'kenajisan': 'najis',
'menajiskan': 'najis',
'bernaka-naka': 'naka',
'menakali': 'nakal',
'menakalinya': 'nakal',
'kenakalan': 'nakal',
'kenakalannya': 'nakal',
'nakal-nakalan': 'nakal',
'menakhodai': 'nakhoda',
'bernala-nala': 'nala',
'bernalam': 'nalam',
'menalamkan': 'nalam',
'bernalar': 'nalar',
'penalaran': 'nalar',
'penalarannya': 'nalar',
'menalarkan': 'nalar',
'kebernalaran': 'nalar',
'menanap': 'nanap',
'ternanar': 'nanar',
'menanarkan': 'nanar',
'senapas': 'napas',
'bernapas': 'napas',
'bernapasnya': 'napas',
'bernapaslah': 'napas',
'bernapaskan': 'napas',
'bernapasan': 'napas',
'pernapasan': 'napas',
'pernapasannya': 'napas',
'menapaskan': 'napas',
'menaskan': 'nas',
'menasakhkan': 'nasakh',
'penasihat': 'nasihat',
'penasihatnya': 'nasihat',
'penasihatan': 'nasihat',
'penasihatku': 'nasihat',
'menasihati': 'nasihat',
'menasihatinya': 'nasihat',
'menasihatiku': 'nasihat',
'menasihatkan': 'nasihat',
'menasihatkannya': 'nasihat',
'menasionalisasi': 'nasionalisasi',
'menasionalisasinya': 'nasionalisasi',
'menasionalisasikan': 'nasionalisasi',
'menasionalisasikannya': 'nasionalisasi',
'menazamkan': 'nazam',
'menegara': 'negara',
'menegarakan': 'negara',
'menegarai': 'negara',
'bernegara': 'negara',
'bernegaranya': 'negara',
'kenegaraan': 'negara',
'kenegaraannya': 'negara',
'kenegarawanan': 'negarawan',
'kenegarawanannya': 'negarawan',
'kenegarawananlah': 'negarawan',
'kenegatifan': 'negatif',
'menegosiasikan': 'negosiasi',
'menegosiasikannya': 'negosiasi',
'nenek-nenek': 'nenek',
'menenes': 'nenes',
'peneonan': 'neon',
'menerakakan': 'neraka',
'kenestapaan': 'nestapa',
'kenetralan': 'netral',
'kenetralannya': 'netral',
'penetralan': 'netral',
'menetralkan': 'netral',
'menetralkannya': 'netral',
'menganga': 'nganga',
'mengangakan': 'nganga',
'mengangai': 'nganga',
'ternganga': 'nganga',
'ternganganya': 'nganga',
'ngeang-ngeang': 'ngeang',
'mengenas': 'ngenas',
'mengenasi': 'ngenas',
'mengiang': 'ngiang',
'terngiang': 'ngiang',
'mengiang-ngiang': 'ngiang',
'terngiang-ngiang': 'ngiang',
'meniaga': 'niaga',
'meniagakan': 'niaga',
'meniagakannya': 'niaga',
'peniaga': 'niaga',
'peniagaan': 'niaga',
'berniaga': 'niaga',
'perniagaan': 'niaga',
'perniagaannya': 'niaga',
'memperniagakan': 'niaga',
'menihilkan': 'nihil',
'menihilkannya': 'nihil',
'penilai': 'nilai',
'penilainya': 'nilai',
'penilaian': 'nilai',
'menilai': 'nilai',
'menilainya': 'nilai',
'menilailah': 'nilai',
'menilaii': 'nilai',
'menilaian': 'nilai',
'menilaiku': 'nilai',
'menilaimu': 'nilai',
'bernilai': 'nilai',
'bernilainya': 'nilai',
'bernilaian': 'nilai',
'ternilai': 'nilai',
'penilaiannya': 'nilai',
'penilaianan': 'nilai',
'penilaianku': 'nilai',
'penilaianmu': 'nilai',
'terninabobo': 'ninabobo',
'terninabobokan': 'ninabobo',
'meninabobokan': 'ninabobo',
'meningratkan': 'ningrat',
'keningrat-ningratan': 'ningrat',
'keniraksaraan': 'niraksara',
'kenisbian': 'nisbi',
'menisbikan': 'nisbi',
'keniscayaan': 'niscaya',
'keniscayaannya': 'niscaya',
'penista': 'nista',
'penistanya': 'nista',
'penistakan': 'nista',
'penistaan': 'nista',
'menista': 'nista',
'menistanya': 'nista',
'menistakan': 'nista',
'menistakannya': 'nista',
'menistai': 'nista',
'menistaan': 'nista',
'nistaan': 'nista',
'ternista': 'nista',
'ternistakan': 'nista',
'kenistaan': 'nista',
'menistakanan': 'nista',
'penobatan': 'nobat',
'penobatannya': 'nobat',
'menobatkan': 'tobat',
'menobatkannya': 'tobat',
'menominasikan': 'nominasi',
'menominasikannya': 'nominasi',
'menomori': 'nomor',
'menomorinya': 'nomor',
'bernomor': 'nomor',
'bernomorkan': 'nomor',
'penomoran': 'nomor',
'penomorannya': 'nomor',
'nona makan sirih': 'nona',
'penonaktifan': 'nonaktif',
'penonaktifannya': 'nonaktif',
'menonaktifkan': 'nonaktif',
'menonaktifkannya': 'nonaktif',
'menonong': 'nonong',
'menormalkan': 'normal',
'menormalkannya': 'normal',
'menormalisasikan': 'normalisasi',
'bernostalgia': 'nostalgia',
'bernostalgialah': 'nostalgia',
'kenotarisan': 'notaris',
'pernovelan': 'novel',
'bernubuat': 'nubuat',
'menubuatkan': 'nubuat',
'kenudisan': 'nudis',
'nujuman': 'nujum',
'menujum': 'nujum',
'penujuman': 'nujum',
'menujumkan': 'nujum',
'menukil': 'nukil',
'menukilkan': 'nukil',
'nukilan': 'nukil',
'nukilannya': 'nukil',
'ternukil': 'nukil',
'nyai-nyai': 'nyai',
'menyalangkan': 'nyalang',
'bernyali': 'nyali',
'bernyalinya': 'nyali',
'bernyalilah': 'nyali',
'nyamikan': 'nyamik',
'ternyana': 'nyana',
'menyanya': 'nyanya',
'menyanyakan': 'nyanya',
'menyanyah': 'nyanyah',
'menyanyu': 'nyanyu',
'senyawa': 'nyawa',
'senyawanya': 'nyawa',
'senyawaan': 'senyawa',
'bernyawa': 'nyawa',
'bernyawakan': 'nyawa',
'bersenyawa': 'senyawa',
'bersenyawanya': 'senyawa',
'persenyawaan': 'senyawa',
'menyenyeh': 'nyenyeh',
'kenyinyiran': 'nyinyir',
'nyolong-nyolong': 'nyolong',
'menyonyong': 'nyonyong',
'menyonyor': 'nyonyor',
'menyunyut': 'nyunyut',
'nyut-nyutan': 'nyut',
'berobat': 'obat',
'berobatnya': 'obat',
'berobatlah': 'obat',
'berobatkan': 'obat',
'berobati': 'obat',
'terobat': 'obat',
'terobati': 'obat',
'pengobat': 'obat',
'pengobatnya': 'obat',
'pengobati': 'obat',
'pengobatan': 'obat',
'terobatinya': 'obat',
'terobatilah': 'obat',
'mengobati': 'obat',
'mengobatinya': 'obat',
'mengobatiku': 'obat',
'pengobatannya': 'obat',
'pengobatanan': 'obat',
'pengobatanku': 'obat',
'mengobatkan': 'obat',
'mengobatkannya': 'obat',
'obat-obatan': 'obat',
'obat-obatannya': 'obat',
'obat-obatanan': 'obat',
'obat-obatanku': 'obat',
'pengobeng': 'obeng',
'mengobeng': 'obeng',
'objekan': 'objek',
'pengobjek': 'objek',
'mengobjek': 'objek',
'mengobjekkan': 'objek',
'pengobjekan': 'objek',
'mengobor': 'obor',
'mengobori': 'obor',
'pengoboran': 'obor',
'obralan': 'obral',
'mengobral': 'obral',
'mengobralnya': 'obral',
'mengobralkan': 'obral',
'mengobralkannya': 'obral',
'pengobralan': 'obral',
'obrolan': 'obrol',
'obrolannya': 'obrol',
'obrolanku': 'obrol',
'obrolanmu': 'obrol',
'mengobrol': 'obrol',
'mengobrollah': 'obrol',
'mengobrolkan': 'obrol',
'mengobrolkannya': 'obrol',
'mengobservasi': 'observasi',
'mengobservasinya': 'observasi',
'mengobservasikan': 'observasi',
'mengobservasiku': 'observasi',
'terobsesi': 'obsesi',
'terobsesinya': 'obsesi',
'odolan': 'odol',
'mengodol': 'odol',
'pengodolan': 'odol',
'mengodol-odol': 'odol',
'mengogah': 'ogah',
'ogah-ogahan': 'ogah',
'berogak-ogak': 'ogak-ogak',
'mengogam': 'ogam',
'mengogel': 'ogel',
'mengogok': 'ogok',
'mengogokkan': 'ogok',
'mengogok-ogok': 'ogok',
'mengoja': 'oja',
'pengojek': 'ojek',
'pengojeknya': 'ojek',
'mengojek': 'ojek',
'mengojeknya': 'ojek',
'mengojekkan': 'ojek',
'mengojok': 'ojok',
'teroksidasi': 'oksidasi',
'pengoksidasi': 'oksidasi',
'mengoksidasi': 'oksidasi',
'beroksigen': 'oksigen',
'olahan': 'olah',
'olahannya': 'olah',
'olahanan': 'olah',
'berolah': 'olah',
'berolahan': 'olah',
'pengolah': 'olah',
'pengolahnya': 'olah',
'pengolahan': 'olah',
'mengolah': 'olah',
'mengolahnya': 'olah',
'mengolahkan': 'olah',
'mengolahan': 'olah',
'pengolahannya': 'olah',
'pengolahanan': 'olah',
'seolah-olah': 'olah',
'seolah-olahnya': 'olah',
'memperolahkan': 'olah',
'mengolak-alik': 'olak-alik',
'mengolak-alikkan': 'olak-alik',
'olang-alingan': 'olang-aling',
'mengolang-aling': 'olang-aling',
'mengolang-alingkan': 'olang-aling',
'mengolek': 'olek',
'mengoleki': 'olek',
'olengan': 'oleng',
'mengoleng': 'oleng',
'teroleng-oleng': 'oleng',
'beroleng-oleng': 'oleng',
'mengoleng-oleng': 'oleng',
'olesan': 'oles',
'olesannya': 'oles',
'mengoles': 'oles',
'mengolesnya': 'oles',
'mengoleskan': 'oles',
'mengoleskannya': 'oles',
'mengolesi': 'oles',
'pengoles': 'oles',
'pengolesnya': 'oles',
'pengolesan': 'oles',
'mengolet': 'olet',
'olok-olok': 'olok',
'olok-oloknya': 'olok',
'olok-olokkan': 'olok',
'olok-olokan': 'olok',
'berolok-olok': 'olok',
'mengolok-olok': 'olok',
'mengolok-oloknya': 'olok',
'mengolok-olokkan': 'olok',
'mengolok-olokku': 'olok',
'memperolok-olok': 'olok',
'memperolok-olokkan': 'olok',
'memperolok-olokan': 'olok',
'berombak': 'ombak',
'mengombak': 'ombak',
'terombang-ambing': 'ombang-ambing',
'terombang-ambingnya': 'ombang-ambing',
'terombang-ambingkan': 'ombang-ambing',
'mengombang-ambing': 'ombang-ambing',
'mengombang-ambingkan': 'ombang-ambing',
'mengombang-ambingkannya': 'ombang-ambing',
'ombyokan': 'ombyok',
'omongan': 'omong',
'omongannya': 'omong',
'omonganlah': 'omong',
'omonganku': 'omong',
'mengomong': 'omong',
'mengomongkannya': 'omong',
'pengomongan': 'omong',
'mengomongkan': 'omong',
'beromong-omong': 'omong',
'mengompol': 'ompol',
'mengompolnya': 'ompol',
'omprengan': 'ompreng',
'mengompreng': 'ompreng',
'pengomprong': 'omprong',
'mengomprong': 'omprong',
'pengomprongan': 'omprong',
'beromzet': 'omzet',
'keonaran': 'onar',
'keonarannya': 'onar',
'mengonarkan': 'onar',
'mengondokkan': 'ondok',
'ondos-ondos': 'ondos',
'onggokan': 'onggok',
'mengonggokkan': 'onggok',
'beronggok-onggok': 'onggok',
'ongkang-ongkang': 'ongkang',
'mengongkang-ongkang': 'ongkang',
'mengongkoki': 'ongkok',
'mengongkok-ongkok': 'ongkok',
'mengonslah': 'onslah',
'mengonyah-anyih': 'onyah-anyih',
'mengonyok': 'onyok',
'mengonyokkan': 'onyok',
'onyotan': 'onyot',
'mengonyot': 'onyot',
'mengopak-apik': 'opak-apik',
'mengopeletkan': 'opelet',
'operan': 'oper',
'operannya': 'oper',
'mengoper': 'oper',
'mengopernya': 'oper',
'mengoperkan': 'oper',
'mengoperkannya': 'oper',
'pengoperan': 'oper',
'beroperasi': 'operasi',
'beroperasinya': 'operasi',
'beroperasilah': 'operasi',
'beroperasikan': 'operasi',
'beroperasii': 'operasi',
'mengoperasi': 'operasi',
'mengoperasinya': 'operasi',
'mengoperasikan': 'operasi',
'mengoperasikannya': 'operasi',
'mengoperasian': 'operasi',
'mengoperasiku': 'operasi',
'pengoperasian': 'operasi',
'pengoperasiannya': 'operasi',
'mengoperasikanan': 'operasi',
'beroplah': 'oplah',
'mengoplos': 'oplos',
'mengoplosnya': 'oplos',
'mengoposisi': 'oposisi',
'mengoposisikan': 'oposisi',
'pengoptimalan': 'optimal',
'pengoptimalannya': 'optimal',
'mengoptimalkan': 'optimal',
'mengoptimalkannya': 'optimal',
'mengoptimalkankan': 'optimal',
'pengoptimuman': 'optimum',
'mengoptimumkan': 'optimum',
'terorak': 'orak',
'pengorak': 'orak',
'mengorak': 'orak',
'mengorak-arik': 'orak-arik',
'pengorak-arik': 'orak-arik',
'seorang': 'orang',
'seorangnya': 'orang',
'seoranglah': 'orang',
'seorangan': 'orang',
'seseorang': 'orang',
'seseoranglah': 'orang',
'seseorangan': 'orang',
'perorangan': 'orang',
'perorangannya': 'orang',
'keseorangan': 'orang',
'mengorangkan': 'orang',
'perseorangan': 'orang',
'perseorangannya': 'orang',
'orang-orangan': 'orang',
'berorang-orang': 'orang',
'berorasi': 'orasi',
'berorasinya': 'orasi',
'mengorat-oret': 'orat-oret',
'mengorbit': 'orbit',
'mengorbitnya': 'orbit',
'mengorbitkan': 'orbit',
'mengorbitkannya': 'orbit',
'mengorbiti': 'orbit',
'pengorbitan': 'orbit',
'pengorbitannya': 'orbit',
'oretan': 'oret',
'mengoret-oret': 'oret',
'terorganisasi': 'organisasi',
'terorganisasikan': 'organisasi',
'berorganisasi': 'organisasi',
'berorganisasilah': 'organisasi',
'pengorganisasi': 'organisasi',
'pengorganisasian': 'organisasi',
'mengorganisasi': 'organisasi',
'mengorganisasikan': 'organisasi',
'mengorganisasikannya': 'organisasi',
'keorganisasian': 'organisasi',
'keorganisasiannya': 'organisasi',
'pengorganisasiannya': 'organisasi',
'berorientasi': 'orientasi',
'berorientasikan': 'orientasi',
'mengorkestrasikan': 'orkestrasi',
'pengornamenan': 'ornamen',
'mengornamenkan': 'ornamen',
'mengorok-orok': 'orok-orok',
'berotak': 'otak',
'berotakkan': 'otak',
'mengotakinya': 'otak',
'otak-otakan': 'otak',
'otak udang': 'mengotaki',
'mengotak-atik': 'otak-atik',
'mengotak-atiknya': 'otak-atik',
'pengotomatisan': 'otomatis',
'mengotomatiskan': 'otomatis',
'berotonomi': 'otonomi',
'pengotonomian': 'otonomi',
'mengotonomikan': 'otonomi',
'mengotot': 'otot',
'mengototnya': 'otot',
'perototan': 'otot',
'ovenan': 'oven',
'mengoyak-oyak': 'oyak',
'mengoyok': 'oyok',
'kepabeanan': 'pabean',
'kepabeanannya': 'pabean',
'kepabeananan': 'pabean',
'berpacangan': 'pacangan',
'pacaran': 'pacar',
'pacarannya': 'pacar',
'memacari': 'pacar',
'memacarinya': 'pacar',
'memacarimu': 'pacar',
'berpacaran': 'pacar',
'berpacarannya': 'pacar',
'memacek': 'pacek',
'pemacek': 'pacek',
'berpacek': 'pacek',
'pemacekan': 'pacek',
'memacik': 'pacik',
'memacu': 'pacu',
'memacunya': 'pacu',
'memacukan': 'pacu',
'memacuku': 'pacu',
'pacuan': 'pacu',
'pacuannya': 'pacu',
'pemacu': 'pacu',
'pemacunya': 'pacu',
'pemacuan': 'pacu',
'berpacu': 'pacu',
'berpacunya': 'pacu',
'berpacuan': 'pacu',
'memacuk': 'pacuk',
'memacul': 'pacul',
'terpacul': 'pacul',
'memadai': 'pada',
'memadainya': 'pada',
'memadailah': 'pada',
'terpada': 'pada',
'kepadaan': 'pada',
'kepadaannya': 'pada',
'memadakan': 'pada',
'memadakannya': 'pada',
'memada-madai': 'pada',
'berpada-pada': 'pada',
'padahan': 'padah',
'pemadam': 'padam',
'pemadamnya': 'padam',
'pemadamkan': 'padam',
'pemadaman': 'padam',
'memadami': 'padam',
'pemadamannya': 'padam',
'pemadamanan': 'padam',
'kepadaman': 'padam',
'memadamkan': 'padam',
'memadamkannya': 'padam',
'memadan': 'padan',
'memadankan': 'padan',
'memadankannya': 'padan',
'memadani': 'padan',
'padanan': 'padan',
'padanannya': 'padan',
'pemadan': 'padan',
'pemadanan': 'padan',
'berpadan': 'padan',
'berpadanan': 'padan',
'bersepadan': 'padan',
'menyepadan': 'padan',
'menyepadankan': 'padan',
'memadan-madan': 'padan',
'sepadan': 'padan',
'berpadang': 'padang',
'berpadangan': 'padang',
'sepadi': 'padi',
'berpadi': 'padi',
'perpadian': 'padi',
'padi-padian': 'padi',
'memaes': 'paes',
'paesan': 'paes',
'paesani': 'paes',
'memagas': 'pagas',
'sepagian': 'pagi',
'kepagian': 'pagi',
'pagi-pagi': 'pagi',
'pagi-paginya': 'pagi',
'sepaha': 'paha',
'berpahala': 'pahala',
'sepaham': 'paham',
'sepahamnya': 'paham',
'sepahamlah': 'paham',
'sepahaman': 'paham',
'memahami': 'paham',
'memahaminya': 'paham',
'memahamilah': 'paham',
'memahamii': 'paham',
'memahamiku': 'paham',
'memahamimu': 'paham',
'berpaham': 'paham',
'berpahamkan': 'paham',
'terpahami': 'paham',
'pemahaman': 'paham',
'pemahamannya': 'paham',
'pemahamanan': 'paham',
'pemahamanku': 'paham',
'pemahamanmu': 'paham',
'memahamkan': 'paham',
'sepahit': 'pahit',
'kepahitan': 'pahit',
'kepahitannya': 'pahit',
'memahitkan': 'pahit',
'berpahit-pahit': 'pahit',
'pailan': 'pail',
'kepailitan': 'pailit',
'kepailitannya': 'pailit',
'pemair': 'pair',
'memairi': 'pair',
'berpair-pair': 'pair',
'pemajak': 'pajak',
'pemajakan': 'pajak',
'memajaki': 'pajak',
'memajakinya': 'pajak',
'pemajakannya': 'pajak',
'perpajakan': 'pajak',
'perpajakannya': 'pajak',
'pemajaan': 'pajan',
'terpajan': 'pajan',
'terpajannya': 'pajan',
'memajankan': 'pajan',
'pajangan': 'pajang',
'pajangannya': 'pajang',
'pemajang': 'pajang',
'pemajangan': 'pajang',
'memajang': 'pajang',
'memajangnya': 'pajang',
'memajangkan': 'pajang',
'pakanan': 'pakan',
'berpakan': 'pakan',
'berpakankan': 'pakan',
'berpakansi': 'pakansi',
'memaksa': 'paksa',
'memaksanya': 'paksa',
'memaksakan': 'paksa',
'memaksakannya': 'paksa',
'memaksaan': 'paksa',
'memaksaku': 'paksa',
'memaksamu': 'paksa',
'paksaan': 'paksa',
'paksaannya': 'paksa',
'terpaksa': 'paksa',
'terpaksanya': 'paksa',
'terpaksalah': 'paksa',
'terpaksai': 'paksa',
'pemaksaan': 'paksa',
'pemaksaannya': 'paksa',
'memaksakanlah': 'paksa',
'keterpaksaan': 'paksa',
'keterpaksaannya': 'paksa',
'keterpaksaanlah': 'paksa',
'memaksa-maksa': 'paksa',
'memakuk': 'pakuk',
'berpal-pal': 'pal',
'sepala-pala': 'pala',
'pemalak': 'palak',
'pemalakan': 'palak',
'memalak': 'palak',
'memalaknya': 'palak',
'memalaki': 'palak',
'memalam': 'palam',
'pemalam': 'palam',
'memalang': 'palang',
'memalangnya': 'palang',
'memalangkan': 'palang',
'memalangkannya': 'palang',
'memalarkan': 'palar',
'palean': 'pale',
'memale': 'pale',
'palingan': 'paling',
'sepaling': 'paling',
'berpaling': 'paling',
'berpalingnya': 'paling',
'berpalinglah': 'paling',
'paling-paling': 'paling',
'memalis': 'palis',
'berpalis': 'palis',
'terpalis': 'palis',
'memaliskan': 'palis',
'paluan': 'palu',
'memalu': 'palu',
'memalunya': 'palu',
'palu-memalu': 'palu',
'berpalu-palu': 'palu',
'berpalu-paluan': 'palu',
'memalun': 'palun',
'memalunkan': 'palun',
'berpalun-palun': 'palun',
'palungan': 'palung',
'pemalut': 'palut',
'memalut': 'palut',
'berpalut': 'palut',
'terpalut': 'palut',
'berpaman': 'paman',
'pameran': 'pamer',
'pamerannya': 'pamer',
'pamerankan': 'pamer',
'berpameran': 'pamer',
'memamerkan': 'pamer',
'memamerkannya': 'pamer',
'memamerkankan': 'pamer',
'memamitkan': 'pamit',
'berpamitan': 'pamit',
'berpamitannya': 'pamit',
'kepamongprajaan': 'pamong praja',
'berpamor': 'pamor',
'memampas': 'pampas',
'pampasan': 'pampas',
'pemampasan': 'pampas',
'memampat': 'pampat',
'memampatkan': 'pampat',
'memampatkannya': 'pampat',
'pemampat': 'pampat',
'pemampatan': 'pampat',
'terpampat': 'pampat',
'kepampatan': 'pampat',
'keterpampatan': 'pampat',
'kepamrihan': 'pamrih',
'terpana': 'pana',
'keterpanaan': 'pana',
'memancal': 'pancal',
'memancarteruskan': 'pancar terus',
'memancit': 'pancit',
'memancit-mancitkan': 'pancit',
'berpanco': 'panco',
'memandakkan': 'pandak',
'memperpandak': 'pandak',
'kepandiran': 'pandir',
'kepandir-pandiran': 'pandir',
'pemandu': 'pandu',
'pemandunya': 'pandu',
'pemanduan': 'pandu',
'pemandumu': 'pandu',
'memandu': 'pandu',
'memandunya': 'pandu',
'memandukan': 'pandu',
'memanduku': 'pandu',
'memandumu': 'pandu',
'panduan': 'pandu',
'panduannya': 'pandu',
'panduanmu': 'pandu',
'berpandu': 'pandu',
'berpandukan': 'pandu',
'berpanduan': 'pandu',
'kepanduan': 'pandu',
'panenan': 'panen',
'panenannya': 'panen',
'memanen': 'panen',
'memanennya': 'panen',
'memanenkan': 'panen',
'memanenkannya': 'panen',
'pemanenan': 'panen',
'pemanenannya': 'panen',
'terpangah': 'pangah',
'memanggakkan': 'panggak',
'panggalan': 'panggal',
'memanggul': 'panggul',
'memanggulnya': 'panggul',
'memanggung': 'panggung',
'memanggungkan': 'panggung',
'memanggungkannya': 'panggung',
'panggungan': 'panggung',
'pemanggungan': 'panggung',
'memangkah': 'pangkah',
'memangkal': 'pangkal',
'memangkalkan': 'pangkal',
'pangkalan': 'pangkal',
'pangkalannya': 'pangkal',
'pangkalanan': 'pangkal',
'berpangkal': 'pangkal',
'berpangkalan': 'pangkal',
'berpangkalanlah': 'pangkal',
'berpangkal tolak': 'pangkal tolak',
'memangkek': 'pangkek',
'pemangku': 'pangku',
'pemangkui': 'pangku',
'pemangkuan': 'pangku',
'memangku': 'pangku',
'memangkunya': 'pangku',
'pangkuan': 'pangku',
'pangkuannya': 'pangku',
'pangkuanku': 'pangku',
'pangkuanmu': 'pangku',
'pangkuan-mu': 'pangku',
'berpangku': 'pangku',
'berpangkuan': 'pangku',
'memangkung': 'pangkung',
'memangkur': 'pangkur',
'berpangsa': 'pangsa',
'memangsakan': 'pangsa',
'kepangsek': 'pangsek',
'berpangsi': 'pangsi',
'memanguk': 'panguk',
'memangur': 'pangur',
'kepanikan': 'panik',
'kepanikannya': 'panik',
'kepanikanku': 'panik',
'kepanikanmu': 'panik',
'kepaniteraan': 'panitera',
'kepanitiaan': 'panitia',
'kepanitiaannya': 'panitia',
'mempanitiai': 'panitia',
'mengarak panja': 'panja',
'memanjang': 'panjang',
'memanjangnya': 'panjang',
'memanjangkan': 'panjang',
'memanjangkannya': 'panjang',
'memanjangi': 'panjang',
'sepanjang': 'panjang',
'sepanjangnya': 'panjang',
'sepanjangan': 'panjang',
'berpanjang': 'panjang',
'berpanjangan': 'panjang',
'pemanjangan': 'panjang',
'kepanjangan': 'panjang',
'kepanjangannya': 'panjang',
'kepanjanganan': 'panjang',
'perpanjangan': 'panjang',
'perpanjangannya': 'panjang',
'perpanjanganan': 'panjang',
'memperpanjang': 'panjang',
'memperpanjangnya': 'panjang',
'memperpanjangkan': 'panjang',
'memperpanjangan': 'panjang',
'pemerpanjangan': 'panjang',
'berkepanjangan': 'panjang',
'berkepanjangannya': 'panjang',
'berkepanjanganlah': 'panjang',
'berpanjang kalam': 'panjang',
'berpanjang-panjang': 'panjang',
'panjatan': 'panjat',
'panjatannya': 'panjat',
'memanjat': 'panjat',
'memanjatnya': 'panjat',
'memanjatlah': 'panjat',
'memanjatkan': 'panjat',
'memanjatkannya': 'panjat',
'memanjati': 'panjat',
'memanjatan': 'panjat',
'pemanjat': 'panjat',
'pemanjatnya': 'panjat',
'pemanjatan': 'panjat',
'pemanjatannya': 'panjat',
'panji-panji': 'panji',
'panji-panjinya': 'panji',
'memanjingkan': 'panjing',
'memanjut': 'panjut',
'memanjutkan': 'panjut',
'memanjut-manjut': 'panjut',
'memantai': 'pantai',
'pantaran': 'pantar',
'pantarannya': 'pantar',
'sepantar': 'pantar',
'sepantaran': 'pantar',
'pemantas': 'pantas',
'pemantasan': 'pantas',
'memantas': 'pantas',
'memantaskan': 'pantas',
'sepantasnya': 'pantas',
'sepantasnyalah': 'pantas',
'memantas-mantas diri': 'pantas',
'memantati': 'pantat',
'pantauan': 'pantau',
'pantauannya': 'pantau',
'pemantau': 'pantau',
'pemantaunya': 'pantau',
'pemantaulah': 'pantau',
'pemantauan': 'pantau',
'memantau': 'pantau',
'memantaunya': 'pantau',
'memantaulah': 'pantau',
'memantauan': 'pantau',
'memantauku': 'pantau',
'memantaumu': 'pantau',
'terpantau': 'pantau',
'terpantaunya': 'pantau',
'terpantaui': 'pantau',
'pemantauannya': 'pantau',
'memantek': 'pantek',
'terpantek': 'pantek',
'pemantik': 'pantik',
'pemantiknya': 'pantik',
'memantik': 'pantik',
'memantiknya': 'pantik',
'memantikkan': 'pantik',
'memantikan': 'pantik',
'pemantikan': 'pantik',
'terpanting': 'panting',
'berpantingan': 'panting',
'memantis': 'pantis',
'sepantun': 'pantun',
'pemantun': 'pantun',
'berpantun': 'pantun',
'memantuni': 'pantun',
'memantunkan': 'pantun',
'berpantun-pantun': 'pantun',
'memapah': 'papah',
'memapahnya': 'papah',
'memapahku': 'papah',
'berpapah': 'papah',
'memapak': 'papak',
'memapaki': 'papak',
'pemapakan': 'papak',
'berpapakan': 'papak',
'memapan': 'papan',
'memapankan': 'papan',
'memapani': 'papan',
'memapras': 'papras',
'para-para': 'para',
'paraban': 'parab',
'berparade': 'parade',
'memaraf': 'paraf',
'memarafnya': 'paraf',
'memparafrasekan': 'parafrase',
'memperparah': 'parah',
'memperparahnya': 'parah',
'memarani': 'paran',
'memarang': 'parang',
'memarangi': 'parang',
'parangan': 'parang',
'memarangkan': 'parang',
'pemarap': 'parap',
'pemarapan': 'parap',
'memarap': 'parap',
'berparap': 'parap',
'memaras': 'paras',
'separas': 'paras',
'separasi': 'paras',
'memarih': 'parih',
'memarit': 'parit',
'berpariwisata': 'pariwisata',
'kepariwisataan': 'pariwisata',
'kepariwisataannya': 'pariwisata',
'memarkir': 'parkir',
'memarkirnya': 'parkir',
'memarkirkan': 'parkir',
'memarkirkannya': 'parkir',
'memarkiran': 'parkir',
'terparkir': 'parkir',
'terparkirnya': 'parkir',
'terparkirkan': 'parkir',
'terparkiri': 'parkir',
'perparkiran': 'parkir',
'perparkirannya': 'parkir',
'memarodikan': 'parodi',
'berpartai': 'partai',
'berpartailah': 'partai',
'kepartaian': 'partai',
'kepartaiannya': 'partai',
'berpartisipasi': 'partisipasi',
'berpartisipasinya': 'partisipasi',
'berpartisipasilah': 'partisipasi',
'berpartner': 'partner',
'paru-paru': 'paru',
'paru-parunya': 'paru',
'paru-paruku': 'paru',
'paru-parumu': 'paru',
'paruhan': 'paruh',
'separuh': 'paruh',
'separuhnya': 'paruh',
'separuhlah': 'paruh',
'separuhnyalah': 'paruh',
'memaruh': 'paruh',
'pemaruh': 'paruh',
'pemarun': 'parun',
'memarun': 'parun',
'parunan': 'parun',
'pemarunan': 'parun',
'mengepas': 'pas',
'mengepasnya': 'pas',
'mengepaskan': 'pas',
'pas-pasan': 'pas',
'pas-pasanlah': 'pas',
'terpasah': 'pasah',
'memasok': 'pasok',
'memasoknya': 'pasok',
'memasoki': 'pasok',
'memasokan': 'pasok',
'pasokan': 'pasok',
'pasokannya': 'pasok',
'pasokani': 'pasok',
'pasokanan': 'pasok',
'pemasok': 'pasok',
'pemasoknya': 'pasok',
'pemasoklah': 'pasok',
'pemasokkan': 'pasok',
'pemasokan': 'pasok',
'pemasokannya': 'pasok',
'memasokkan': 'pasok',
'berpaspor': 'paspor',
'berpasporkan': 'paspor',
'berpasrah': 'pasrah',
'kepasrahan': 'pasrah',
'kepasrahannya': 'pasrah',
'kepasrahanku': 'pasrah',
'memasrahkan': 'pasrah',
'memasrahkannya': 'pasrah',
'dipasteurisasi': 'pasteurisasi',
'pemastian': 'pasti',
'pemastiannya': 'pasti',
'kepastian': 'pasti',
'kepastiannya': 'pasti',
'kepastianlah': 'pasti',
'memastikan': 'pasti',
'memastikannya': 'pasti',
'memastikanan': 'pasti',
'pastoran': 'pastor',
'pasukan': 'pasuk',
'pasukannya': 'pasuk',
'pasukanlah': 'pasuk',
'pasukanan': 'pasuk',
'pasukanku': 'pasuk',
'pasukanmu': 'pasuk',
'berpasuk-pasuk': 'pasuk',
'memasung': 'pasung',
'memasungnya': 'pasung',
'pasungan': 'pasung',
'pasungannya': 'pasung',
'pemasungan': 'pasung',
'pemasungannya': 'pasung',
'memasungkan': 'pasung',
'berpatam': 'patam',
'mematar': 'patar',
'mematenkan': 'paten',
'mematenkannya': 'paten',
'pematih': 'patih',
'pematihan': 'patih',
'kepatihan': 'patih',
'mematik': 'patik',
'mematiknya': 'patik',
'mematikkan': 'patik',
'mematil': 'patil',
'memating': 'pating',
'patokan': 'patok',
'patokannya': 'patok',
'patokanan': 'patok',
'mematok': 'patok',
'mematoknya': 'patok',
'mematokkan': 'patok',
'mematokan': 'patok',
'pematokan': 'patok',
'pematokannya': 'patok',
'mematri': 'patri',
'mematrikan': 'patri',
'patrian': 'patri',
'patriani': 'patri',
'pematri': 'patri',
'pematrian': 'patri',
'terpatri': 'patri',
'terpatrikan': 'patri',
'mempatroli': 'patroli',
'berpatroli': 'patroli',
'mematuhi': 'patuh',
'mematuhinya': 'patuh',
'mematuhiku': 'patuh',
'kepatuhan': 'patuh',
'kepatuhannya': 'patuh',
'pematuhan': 'patuh',
'pematung': 'patung',
'pematungnya': 'patung',
'mematung': 'patung',
'mematungnya': 'patung',
'mematungkan': 'patung',
'berpatungan': 'patungan',
'mematut': 'patut',
'mematutkan': 'patut',
'kepatutan': 'patut',
'kepatutannya': 'patut',
'berpatutan': 'patut',
'sepatutnya': 'patut',
'sepatutnyalah': 'patut',
'mematut-matut': 'patut',
'memauk': 'pauk',
'memaukkan': 'pauk',
'memauki': 'pauk',
'pemauk': 'pauk',
'kepausan': 'paus',
'kepausannya': 'paus',
'berpawai': 'pawai',
'memayang': 'payang',
'pemayar': 'payar',
'pemayaran': 'payar',
'berpayudara': 'payudara',
'memayungi': 'payung',
'memayunginya': 'payung',
'berpayung': 'payung',
'berpayungkan': 'payung',
'berpayungan': 'payung',
'memayungkan': 'payung',
'memecakkan': 'pecak',
'memecal': 'pecal',
'memeda': 'peda',
'memedai': 'peda',
'memedang': 'pedang',
'kepedihan': 'pedih',
'kepedihannya': 'pedih',
'memedihkan': 'pedih',
'berpedoman': 'pedoman',
'memedomani': 'pedoman',
'kepedulian': 'peduli',
'kepeduliannya': 'peduli',
'kepedulianlah': 'peduli',
'memedulikan': 'peduli',
'memedulikannya': 'peduli',
'terpegah': 'pegah',
'memegalkan': 'pegal',
'terpegan': 'pegan',
'memegas': 'pegas',
'memegaskan': 'pegas',
'memegat': 'pegat',
'pemegatan': 'pegat',
'kepegawaian': 'pegawai',
'kepegawaiannya': 'pegawai',
'kepegawaianan': 'pegawai',
'kepegawaianmu': 'pegawai',
'terpegun': 'pegun',
'terpejam': 'pejam',
'memejamkan': 'pejam',
'memejamkannya': 'pejam',
'kepekatan': 'pekat',
'kepekatannya': 'pekat',
'memekatkan': 'pekat',
'memekau': 'pekau',
'memeking': 'peking',
'memekis': 'pekis',
'sepeku': 'peku',
'memekuk': 'pekuk',
'mengepel': 'pel',
'mengepelnya': 'pel',
'memelankan': 'pelan',
'memelankannya': 'pelan',
'pelan-pelan': 'pelan',
'pelan-pelanlah': 'pelan',
'memelana': 'pelana',
'berpelana': 'pelana',
'terpelanting': 'pelanting',
'memelaspas': 'pelaspas',
'berpelatuk': 'pelatuk',
'pelawaan': 'pelawa',
'memelawa': 'pelawa',
'memeleceh': 'peleceh',
'terpelecok': 'pelecok',
'terpelekok': 'pelekok',
'terpelencit': 'pelencit',
'terpelengak': 'pelengak',
'berpelepah': 'pelepah',
'memelesat': 'pelesat',
'terpelesat': 'pelesat',
'pelesiran': 'pelesir',
'pelesirannya': 'pelesir',
'berpelesir': 'pelesir',
'berpelesiran': 'pelesir',
'peletan': 'pelet',
'memelet': 'pelet',
'memeletnya': 'pelet',
'memeletek': 'peletek',
'peliharaan': 'pelihara',
'peliharaannya': 'pelihara',
'peliharaanku': 'pelihara',
'peliharaanmu': 'pelihara',
'pemelihara': 'pelihara',
'pemeliharanya': 'pelihara',
'pemeliharaan': 'pelihara',
'memelihara': 'pelihara',
'memeliharanya': 'pelihara',
'memeliharamu': 'pelihara',
'terpelihara': 'pelihara',
'terpeliharanya': 'pelihara',
'pemeliharaannya': 'pelihara',
'memeliharakan': 'pelihara',
'pelintiran': 'pelintir',
'pelintirannya': 'pelintir',
'memelintir': 'pelintir',
'memelintirnya': 'pelintir',
'memelintirkan': 'pelintir',
'pemelintir': 'pelintir',
'pemelintiran': 'pelintir',
'terpelintir': 'pelintir',
'terpelintirnya': 'pelintir',
'memelintir-melintir': 'pelintir',
'pelipisan': 'pelipis',
'memelisit': 'pelisit',
'kepelitan': 'pelit',
'memelitur': 'pelitur',
'pelituran': 'pelitur',
'berpelitur': 'pelitur',
'memelonco': 'pelonco',
'perpeloncoan': 'pelonco',
'memelopori': 'pelopor',
'memeloporinya': 'pelopor',
'kepeloporan': 'pelopor',
'kepeloporannya': 'pelopor',
'memeloroti': 'pelorot',
'terpelosot': 'pelosot',
'memelotot': 'pelotot',
'memelototkan': 'pelotot',
'memelototi': 'pelotot',
'memelototinya': 'pelotot',
'memelototiku': 'pelotot',
'berpeluang': 'peluang',
'berpeluangnya': 'peluang',
'berpeluangan': 'peluang',
'berpematang': 'pematang',
'berpentas': 'pentas',
'pementasan': 'pentas',
'pementasannya': 'pentas',
'mementaskan': 'pentas',
'mementaskannya': 'pentas',
'pemerintah': 'perintah',
'pemerintahnya': 'perintah',
'pemerintahlah': 'perintah',
'pemerintahkan': 'perintah',
'pemerintahi': 'perintah',
'pemerintahan': 'perintah',
'pemerintahku': 'perintah',
'pemerintahmu': 'perintah',
'memerintah': 'perintah',
'memerintahnya': 'perintah',
'memerintahkan': 'perintah',
'memerintahkannya': 'perintah',
'memerintahan': 'perintah',
'memerintahmu': 'perintah',
'terperintah': 'perintah',
'memerintahi': 'perintah',
'pemerintahannya': 'perintah',
'pemerintahanlah': 'perintah',
'pemerintahanan': 'perintah',
'pemerintahannyalah': 'perintah',
'pemerintahanku': 'perintah',
'pemerintahanmu': 'perintah',
'memerintahkankan': 'perintah',
'memerintahkanku': 'perintah',
'memerintahkanmu': 'perintah',
'berpemerintahan': 'perintah',
'petaan': 'peta',
'terpeta': 'peta',
'terpetakan': 'peta',
'terpetakannya': 'peta',
'pemetaan': 'peta',
'pemetaannya': 'peta',
'perpetaan': 'peta',
'perpetaannya': 'peta',
'memetakan': 'peta',
'memetakannya': 'peta',
'pemidangan': 'pemidang',
'pemirsa': 'pirsa',
'pemirsanya': 'pirsa',
'penambang': 'tambang',
'penambangnya': 'tambang',
'penambangan': 'tambang',
'menambang': 'tambang',
'menambangnya': 'tambang',
'menambangkan': 'tambang',
'menambangan': 'tambang',
'tambangan': 'tambang',
'penambangannya': 'tambang',
'bertambangan': 'tambang',
'pertambangan': 'tambang',
'pertambangannya': 'tambang',
'pertambanganlah': 'tambang',
'penampilan': 'tampil',
'penampilannya': 'tampil',
'penampilannyalah': 'tampil',
'penampilanku': 'tampil',
'penampilanmu': 'tampil',
'menampilkan': 'tampil',
'menampilkannya': 'tampil',
'menampilkankan': 'tampil',
'berpenampilan': 'tampil',
'berpenampilannya': 'tampil',
'berpenampilanlah': 'tampil',
'penangkal': 'tangkal',
'penangkalnya': 'tangkal',
'penangkalan': 'tangkal',
'menangkal': 'tangkal',
'menangkalnya': 'tangkal',
'menangkali': 'tangkal',
'tertangkal': 'tangkal',
'penangkalannya': 'tangkal',
'menangkalkan': 'tangkal',
'memencak-mencak': 'pencak',
'memencet': 'pencet',
'memencetnya': 'pencet',
'memenceti': 'pencet',
'kepencut': 'pencut',
'memenda': 'penda',
'pendaan': 'penda',
'pendaannya': 'penda',
'pendaanan': 'penda',
'memendaki': 'pendak',
'pendaran': 'pendar',
'berpendar': 'pendar',
'berpendarnya': 'pendar',
'berpendaran': 'pendar',
'berpendar-pendar': 'pendar',
'memendek': 'pendek',
'memendeknya': 'pendek',
'memendekkan': 'pendek',
'memendekkannya': 'pendek',
'memendekan': 'pendek',
'pemendekan': 'pendek',
'kependekan': 'pendek',
'kependetaan': 'pendeta',
'kependetaannya': 'pendeta',
'berpending': 'pending',
'berpendingan': 'pending',
'menegas': 'tegas',
'menegasnya': 'tegas',
'menegaskan': 'tegas',
'menegaskannya': 'tegas',
'menegasi': 'tegas',
'menegasan': 'tegas',
'penegasan': 'tegas',
'penegasannya': 'tegas',
'ketegasan': 'tegas',
'ketegasannya': 'tegas',
'ketegasanlah': 'tegas',
'ketegasanan': 'tegas',
'ketegasanmu': 'tegas',
'menegaskankan': 'tegas',
'menegaskanku': 'tegas',
'pertegasan': 'tegas',
'mempertegas': 'tegas',
'mempertegasnya': 'tegas',
'mempertegaskan': 'tegas',
'penerbang': 'terbang',
'penerbangnya': 'terbang',
'penerbangkan': 'terbang',
'penerbangan': 'terbang',
'menerbangi': 'terbang',
'menerbanginya': 'terbang',
'penerbangannya': 'terbang',
'penerbanganan': 'terbang',
'penerbanganku': 'terbang',
'beterbangan': 'terbang',
'beterbangannya': 'terbang',
'menerbangkan': 'terbang',
'menerbangkannya': 'terbang',
'terbang-terbang': 'terbang',
'terbang-terbangan': 'terbang',
'terbang-terbang hinggap': 'terbang',
'berpenetrasi': 'penetrasi',
'berpengantin': 'pengantin',
'memengap': 'pengap',
'kepengapan': 'pengap',
'memengapkan': 'pengap',
'memengat': 'pengat',
'pengkolan': 'pengkol',
'memengkol': 'pengkol',
'memengos': 'pengos',
'tiduran': 'tidur',
'penidur': 'tidur',
'peniduran': 'tidur',
'meniduri': 'tidur',
'menidurinya': 'tidur',
'menidurimu': 'tidur',
'tertidur': 'tidur',
'tertidurnya': 'tidur',
'petiduran': 'tidur',
'ketiduran': 'tidur',
'menidurkan': 'tidur',
'menidurkannya': 'tidur',
'seketiduran': 'tidur',
'tidur-tidur': 'tidur',
'tidur-tiduran': 'tidur',
'berseketiduran': 'tidur',
'ketidur-tiduran': 'tidur',
'penimbal': 'timbal',
'timbalan': 'timbal',
'menimbal': 'timbal',
'menimbalkan': 'timbal',
'setimbal': 'timbal',
'bertimbal': 'timbal',
'menimbali': 'timbal',
'bertimbalan': 'timbal',
'kesetimbalan': 'timbal',
'bertimbal-timbalan': 'timbal',
'memensiun': 'pensiun',
'memensiunkan': 'pensiun',
'memensiunkannya': 'pensiun',
'pensiunan': 'pensiun',
'pensiunannya': 'pensiun',
'penyair': 'syair',
'penyairnya': 'syair',
'penyairan': 'syair',
'penyairku': 'syair',
'pensyair': 'syair',
'bersyair': 'syair',
'bersyairkan': 'syair',
'menyairkan': 'syair',
'kepenyairan': 'syair',
'kepenyairannya': 'syair',
'terpental': 'pental',
'terpentalnya': 'pental',
'mementang': 'pentang',
'terpentang': 'pentang',
'mementil': 'pentil',
'pentolan': 'pentol',
'pentolannya': 'pentol',
'berpentol': 'pentol',
'pentungan': 'pentung',
'pentungannya': 'pentung',
'mementung': 'pentung',
'mementungi': 'pentung',
'pentung-pentungan': 'pentung',
'dituai': 'tuai',
'dituainya': 'tuai',
'penuai': 'tuai',
'penuaian': 'tuai',
'menuai': 'tuai',
'menuainya': 'tuai',
'menuaikan': 'tuai',
'menuaii': 'tuai',
'tuaian': 'tuai',
'menumpang': 'tumpang',
'menumpangnya': 'tumpang',
'menumpanglah': 'tumpang',
'menumpangkan': 'tumpang',
'menumpangkannya': 'tumpang',
'menumpangi': 'tumpang',
'penumpang': 'tumpang',
'penumpangnya': 'tumpang',
'penumpanglah': 'tumpang',
'penumpangkan': 'tumpang',
'penumpangan': 'tumpang',
'penumpangku': 'tumpang',
'tumpangan': 'tumpang',
'tumpangannya': 'tumpang',
'tertumpang': 'tumpang',
'tertumpangi': 'tumpang',
'menumpanginya': 'tumpang',
'penumpangannya': 'tumpang',
'tunjangan': 'tunjang',
'tunjangannya': 'tunjang',
'penunjang': 'tunjang',
'penunjangnya': 'tunjang',
'penunjangan': 'tunjang',
'menunjang': 'tunjang',
'menunjangnya': 'tunjang',
'menunjangkan': 'tunjang',
'tertunjang': 'tunjang',
'bersajak': 'sajak',
'penyajak': 'sajak',
'menyajak': 'sajak',
'persajakan': 'sajak',
'menyajakkan': 'sajak',
'menyalir': 'salir',
'penyaliran': 'salir',
'sandangan': 'sandang',
'penyandang': 'sandang',
'penyandangnya': 'sandang',
'penyandangan': 'sandang',
'menyandang': 'sandang',
'menyandangnya': 'sandang',
'menyandangkan': 'sandang',
'mempersandangkan': 'sandang',
'saringan': 'saring',
'saringannya': 'saring',
'menyaring': 'saring',
'menyaringnya': 'saring',
'menyaringan': 'saring',
'penyaring': 'saring',
'penyaringnya': 'saring',
'penyaringan': 'saring',
'penyaringannya': 'saring',
'semburan': 'sembur',
'semburannya': 'sembur',
'penyembur': 'sembur',
'penyemburkan': 'sembur',
'penyemburan': 'sembur',
'tersembur': 'sembur',
'tersemburlah': 'sembur',
'menyembur': 'sembur',
'menyemburnya': 'sembur',
'menyemburkan': 'sembur',
'menyemburkannya': 'sembur',
'menyemburi': 'sembur',
'bersemburan': 'sembur',
'penyemburannya': 'sembur',
'sembur-sembur': 'sembur',
'bersembur-semburan': 'sembur',
'semprotan': 'semprot',
'semprotannya': 'semprot',
'menyemprot': 'semprot',
'menyemprotnya': 'semprot',
'menyemprotkan': 'semprot',
'menyemprotkannya': 'semprot',
'menyemproti': 'semprot',
'menyemprotan': 'semprot',
'penyemprot': 'semprot',
'penyemprotnya': 'semprot',
'penyemprotkan': 'semprot',
'penyemprotan': 'semprot',
'penyemprotannya': 'semprot',
'menyengap': 'sengap',
'penyengap': 'sengap',
'menyengapkan': 'sengap',
'serahan': 'serah',
'menyerah': 'serah',
'menyerahnya': 'serah',
'menyerahlah': 'serah',
'menyerahkan': 'serah',
'menyerahkannya': 'serah',
'menyerahan': 'serah',
'terserah': 'serah',
'terserahnya': 'serah',
'terserahlah': 'serah',
'berserah': 'serah',
'berserahlah': 'serah',
'berserahkan': 'serah',
'berserahan': 'serah',
'seserahan': 'serah',
'seserahannya': 'serah',
'menyerahi': 'serah',
'penyerahan': 'serah',
'penyerahannya': 'serah',
'penyerahanan': 'serah',
'menyerahkankan': 'serah',
'menyerahkani': 'serah',
'menyerahkanku': 'serah',
'menyerahkanmu': 'serah',
'memepah': 'pepah',
'sepepak': 'pepak',
'memepak': 'pepak',
'memepas': 'pepas',
'memepat': 'pepat',
'memepati': 'pepat',
'berpepat': 'pepat',
'memeper': 'peper',
'memeperkan': 'peper',
'terpeper': 'peper',
'pepesan': 'pepes',
'pepesanan': 'pepes',
'memepes': 'pepes',
'memepet': 'pepet',
'memepetnya': 'pepet',
'memepetkan': 'pepet',
'kepepet': 'pepet',
'kepepetnya': 'pepet',
'memepeti': 'pepet',
'terpepet': 'pepet',
'meraga': 'raga',
'meragakan': 'raga',
'peraga': 'raga',
'peraganya': 'raga',
'peragakan': 'raga',
'peragaan': 'raga',
'peragaannya': 'raga',
'pemeraga': 'raga',
'pemeragaan': 'raga',
'memperagakan': 'raga',
'memperagakannya': 'raga',
'keperagawanan': 'peragawan',
'keperagawatian': 'peragawati',
'perah keringat': 'perah otak',
'berperahu': 'perahu',
'memerai': 'perai',
'berperai-perai': 'perai',
'teraih': 'raih',
'peraih': 'raih',
'peraihnya': 'raih',
'peraihan': 'raih',
'meraih': 'raih',
'meraihnya': 'raih',
'meraihkan': 'raih',
'meraihan': 'raih',
'meraihku': 'raih',
'meraihmu': 'raih',
'keperakan': 'perak',
'keperakannya': 'perak',
'keperak-perakan': 'perak',
'pemeran': 'peran',
'pemerannya': 'peran',
'pemeranan': 'peran',
'peranan': 'peran',
'peranannya': 'peran',
'perananan': 'peran',
'berperan': 'peran',
'berperannya': 'peran',
'berperanlah': 'peran',
'berperanan': 'peran',
'memerankan': 'peran',
'memerankannya': 'peran',
'memerankanku': 'peran',
'berperan serta': 'peran serta',
'perancah': 'rancah',
'perancahnya': 'rancah',
'memerangi': 'perang',
'memeranginya': 'perang',
'memerangimu': 'perang',
'berperang': 'perang',
'berperangnya': 'perang',
'berperangan': 'perang',
'peperangan': 'perang',
'peperangannya': 'perang',
'peperanganku': 'perang',
'berperang-perangan': 'perang',
'terperangah': 'perangah',
'terperangahnya': 'perangah',
'memerangahkan': 'perangah',
'seperanggu': 'peranggu',
'seperangguan': 'peranggu',
'merangkap': 'rangkap',
'merangkapnya': 'rangkap',
'merangkapkan': 'rangkap',
'berangkap': 'rangkap',
'perangkap': 'rangkap',
'perangkapnya': 'rangkap',
'perangkapan': 'rangkap',
'perangkapku': 'rangkap',
'berangkap-rangkapan': 'rangkap',
'memerap': 'perap',
'memerapkan': 'perap',
'terperap': 'perap',
'berperata': 'perata',
'memerawani': 'perawan',
'keperawanan': 'perawan',
'keperawanannya': 'perawan',
'keperawananku': 'perawan',
'keperawananmu': 'perawan',
'diperbal': 'perbal',
'memerban': 'perban',
'memercit': 'percit',
'tepercit': 'percit',
'tepercul': 'percul',
'diperdanakan': 'perdana',
'diperdom': 'perdom',
'diperdomi': 'perdom',
'terperedus': 'peredus',
'terpereh-pereh': 'pereh',
'keperempuanan': 'perempuan',
'keperempuanannya': 'perempuan',
'terperenyuk': 'perenyuk',
'memereteli': 'peretel',
'pemeretelan': 'peretel',
'kepergok': 'pergok',
'kepergoknya': 'pergok',
'tepergok': 'pergok',
'tepergoknya': 'pergok',
'tepergoki': 'pergok',
'memergoki': 'pergok',
'memergokinya': 'pergok',
'memergokiku': 'pergok',
'memergol': 'pergol',
'memergoli': 'pergol',
'berperi': 'peri',
'berperikan': 'peri',
'pemerian': 'peri',
'memerikan': 'peri',
'terperikan': 'peri',
'keperigelan': 'perigel',
'perincian': 'perinci',
'perinciannya': 'perinci',
'memerinci': 'perinci',
'memerincinya': 'perinci',
'memerincikan': 'perinci',
'terperinci': 'perinci',
'pemerincian': 'perinci',
'memeringis': 'peringis',
'rintangan': 'rintang',
'rintangannya': 'rintang',
'rintanganlah': 'rintang',
'perintang': 'rintang',
'perintangan': 'rintang',
'merintang': 'rintang',
'merintangi': 'rintang',
'terintang': 'rintang',
'terintangi': 'rintang',
'merintanginya': 'rintang',
'merintangkan': 'rintang',
'perintang-rintang': 'rintang',
'merintang-rintang': 'rintang',
'berperistiwa': 'peristiwa',
'beperkara': 'perkara',
'beperkaralah': 'perkara',
'memperkarai': 'perkara',
'memperkarakan': 'perkara',
'memperkarakannya': 'perkara',
'memerkosa': 'perkosa',
'memerkosanya': 'perkosa',
'memerkosaan': 'perkosa',
'memerkosaku': 'perkosa',
'pemerkosa': 'perkosa',
'pemerkosanya': 'perkosa',
'pemerkosaan': 'perkosa',
'pemerkosaku': 'perkosa',
'pemerkosaannya': 'perkosa',
'memerlahan': 'perlahan',
'memerlahankan': 'perlahan',
'perlahan-lahan': 'perlahan',
'perlahan-lahanlah': 'perlahan',
'perlian': 'perli',
'memerli': 'perli',
'memerlikan': 'perli',
'teperling': 'perling',
'perlip-perlipan': 'perlip',
'teperlus': 'perlus',
'kepermaian': 'permai',
'memermak': 'permak',
'memermaknya': 'permak',
'tepermanai': 'permana',
'mempermisikan': 'permisi',
'pernak-pernik': 'pernik',
'pernak-perniknya': 'pernik',
'pernik-pernik': 'pernik',
'memernis': 'pernis',
'pernisan': 'pernis',
'memerogol': 'perogol',
'terperohong': 'perohong',
'terperonyok': 'peronyok',
'terperosok': 'perosok',
'terperosoknya': 'perosok',
'merosot': 'perosot',
'memerosot': 'perosot',
'memerosotkan': 'perosot',
'kepustakaan': 'pustaka',
'perpustakaan': 'pustaka',
'perpustakaannya': 'pustaka',
'bersahabat': 'sahabat',
'bersahabatnya': 'sahabat',
'bersahabatlah': 'sahabat',
'bersahabatan': 'sahabat',
'persahabatan': 'sahabat',
'persahabatannya': 'sahabat',
'persahabatanlah': 'sahabat',
'persahabatanku': 'sahabat',
'persahabatanmu': 'sahabat',
'mempersahabatkan': 'sahabat',
'bersegi': 'segi',
'persegi': 'segi',
'perseginya': 'segi',
'memersekoti': 'persekot',
'mempersekoti': 'persekot',
'memersekusi': 'persekusi',
'persenan': 'persen',
'persenannya': 'persen',
'persenanlah': 'persen',
'memerseni': 'persen',
'memersenkan': 'persen',
'bersenjata': 'senjata',
'bersenjatanya': 'senjata',
'bersenjatalah': 'senjata',
'bersenjatakan': 'senjata',
'kesenjataan': 'senjata',
'kesenjataannya': 'senjata',
'persenjataan': 'senjata',
'persenjataannya': 'senjata',
'mempersenjatai': 'senjata',
'mempersenjatainya': 'senjata',
'tersenyawa': 'senyawa',
'memersepsikan': 'persepsi',
'memersepsikannya': 'persepsi',
'seratus': 'ratus',
'seratusnya': 'ratus',
'seratusan': 'ratus',
'ratusan': 'ratus',
'ratusannya': 'ratus',
'ratusanlah': 'ratus',
'ratusanan': 'ratus',
'meratus': 'ratus',
'peratus': 'ratus',
'peratusan': 'ratus',
'seperatus': 'ratus',
'menyeratus': 'ratus',
'perseratus': 'ratus',
'seperseratus': 'ratus',
'seperseratusnya': 'ratus',
'beratus-ratus': 'ratus',
'pesero': 'sero',
'peseroan': 'sero',
'perseroan': 'sero',
'perseroannya': 'sero',
'perseroankan': 'sero',
'berseteru': 'seteru',
'berseterunya': 'seteru',
'berseteruan': 'seteru',
'menyeterui': 'seteru',
'perseteruan': 'seteru',
'perseteruannya': 'seteru',
'memperseterukan': 'seteru',
'setubuh': 'tubuh',
'setubuhnya': 'tubuh',
'setubuhi': 'tubuh',
'bertubuh': 'tubuh',
'menubuhkan': 'tubuh',
'pertubuhan': 'tubuh',
'bersetubuh': 'tubuh',
'bersetubuhi': 'tubuh',
'bersetubuhan': 'tubuh',
'menyetubuhi': 'tubuh',
'menyetubuhinya': 'tubuh',
'persetubuhan': 'tubuh',
'persetubuhannya': 'tubuh',
'tepersil': 'persil',
'memersonanongratakan': 'persona nongrata',
'memersonifikasi': 'personifikasi',
'memersonifikasikan': 'personifikasi',
'memersuasi': 'persuasi',
'pertalan': 'pertal',
'memert al': 'pertal',
'memertamakan': 'pertama',
'pertama-tama': 'pertama',
'pertama-tamanya': 'pertama',
'terperuak': 'peruak',
'memeruk': 'peruk',
'memerukan': 'peruk',
'terperuk': 'peruk',
'memerukkan': 'peruk',
'memerum': 'perum',
'memerun': 'perun',
'pemerunan': 'perun',
'seperunjung': 'perunjung',
'seperunjungan': 'perunjung',
'memerusa': 'perusa',
'seperut': 'perut',
'memeruti': 'perut',
'berperut': 'perut',
'perwalian': 'wali',
'perwaliannya': 'wali',
'mewalikan': 'wali',
'memperwalikan': 'wali',
'berwatak': 'watak',
'berwatakkan': 'watak',
'mewataki': 'watak',
'perwatakan': 'watak',
'berpesai-pesai': 'pesai',
'memesamkan': 'pesam',
'pesangon': 'sangon',
'pesangonnya': 'sangon',
'pesangonlah': 'sangon',
'pesangonkan': 'sangon',
'pesangonan': 'sangon',
'berpesawat': 'pesawat',
'sepeser': 'peser',
'memesona': 'pesona',
'memesonanya': 'pesona',
'memesonakan': 'pesona',
'terpesona': 'pesona',
'terpesonanya': 'pesona',
'memesonai': 'pesona',
'memesonakanku': 'pesona',
'berpesta pora': 'pesta pora',
'kepetah-lidahan': 'petah lidah',
'petakan': 'petak',
'petakannya': 'petak',
'berpetak': 'petak',
'memetak-metak': 'petak',
'berpetak-petak': 'petak',
'memetalkan': 'petal',
'berpetam': 'petam',
'kepetangan': 'petang',
'petang-petang': 'petang',
'sepetang-petangan': 'petang',
'pemetang-metangan': 'petang',
'memetang-metangkan': 'petang',
'2 tani': 'tani',
'petani': 'tani',
'petaninya': 'tani',
'petanilah': 'tani',
'petanian': 'tani',
'bertani': 'tani',
'bertaninya': 'tani',
'pertanian': 'tani',
'pertaniannya': 'tani',
'pertanianan': 'tani',
'petasan': 'petas',
'petasannya': 'petas',
'petentengan': 'petenteng',
'memetieskan': 'peti es',
'berpeti-peti': 'peti',
'memetia': 'petia',
'memetiakan': 'petia',
'memeting': 'peting',
'memetingkan': 'peting',
'memetir-metir': 'petir',
'berpetua': 'petua',
'dipetuakan': 'petua',
'berpetuah': 'petuah',
'memetuahkan': 'petuah',
'pewawancara': 'wawancara',
'pewawancaranya': 'wawancara',
'pewawancaramu': 'wawancara',
'mewawancarai': 'wawancara',
'mewawancarainya': 'wawancara',
'mewawancaraiku': 'wawancara',
'mewawancaraimu': 'wawancara',
'berwawancara': 'wawancara',
'terwawancara': 'wawancara',
'memiagamkan': 'piagam',
'berpialang': 'pialang',
'memialangkan': 'pialang',
'berpiama': 'piama',
'memiang': 'piang',
'memiangnya': 'piang',
'pemiara': 'piara',
'piaraan': 'piara',
'piaraannya': 'piara',
'piaraanku': 'piara',
'memiara': 'piara',
'pemiaraan': 'piara',
'memiat': 'piat',
'piat-piut': 'piat',
'kepiatuan': 'piatu',
'kepiawaian': 'piawai',
'kepiawaiannya': 'piawai',
'terpica': 'pica',
'memicakan': 'pica',
'kepicikan': 'picik',
'memicikkan': 'picik',
'memicing': 'picing',
'memicingkan': 'picing',
'sepicing': 'picing',
'terpicing': 'picing',
'berpicing': 'picing',
'picisan': 'picis',
'sepicis': 'picis',
'terpico': 'pico',
'memicu': 'picu',
'memicunya': 'picu',
'memicui': 'picu',
'memicuku': 'picu',
'pemicu': 'picu',
'pemicunya': 'picu',
'pemiculah': 'picu',
'pemicuan': 'picu',
'memidana': 'pidana',
'memidanakan': 'pidana',
'memidanakannya': 'pidana',
'terpidana': 'pidana',
'terpidananya': 'pidana',
'terpidanai': 'pidana',
'berpidana': 'pidana',
'pemidanaan': 'pidana',
'pemidanaannya': 'pidana',
'memidi': 'pidi',
'memijah': 'pijah',
'memijahnya': 'pijah',
'memijahkan': 'pijah',
'pemijahan': 'pijah',
'pemijahannya': 'pijah',
'memijat': 'pijat',
'memijatnya': 'pijat',
'memijatkan': 'pijat',
'memijatkannya': 'pijat',
'memijati': 'pijat',
'memijatmu': 'pijat',
'pemijat': 'pijat',
'pemijatnya': 'pijat',
'pemijatan': 'pijat',
'pijatan': 'pijat',
'pijatannya': 'pijat',
'pemijatannya': 'pijat',
'pijat-pijat': 'pijat',
'pijat-pijatlah': 'pijat',
'pijat-pijatan': 'pijat',
'memijit': 'pijit',
'memijitnya': 'pijit',
'terpijit': 'pijit',
'berpikauan': 'pikau',
'terpikau-pikau': 'pikau',
'berpiknik': 'piknik',
'memikul': 'pikul',
'memikulnya': 'pikul',
'memikulkan': 'pikul',
'pemikul': 'pikul',
'pemikulan': 'pikul',
'pikulan': 'pikul',
'pikulannya': 'pikul',
'berpikul-pikul': 'pikul',
'memilah': 'pilah',
'memilahnya': 'pilah',
'memilahkan': 'pilah',
'terpilah': 'pilah',
'terpilah-pilah': 'pilah',
'memilis': 'pilis',
'berpilis': 'pilis',
'memiloti': 'pilot',
'berpinak': 'pinak',
'berpinar': 'pinar',
'memincuk': 'pincuk',
'kepincuk': 'pincuk',
'terpincut': 'pincut',
'terpincutnya': 'pincut',
'pindaan': 'pinda',
'meminda': 'pinda',
'memindakan': 'pinda',
'memindai': 'pindai',
'pemindaan': 'pinda',
'memindahtangankan': 'pindah tangan',
'memindahtugaskan': 'pindah tugas',
'memindahtugaskannya': 'pindah tugas',
'memindainya': 'pindai',
'pemindai': 'pindai',
'pemindainya': 'pindai',
'pemindaian': 'pindai',
'pemindaiannya': 'pindai',
'terpinga-pinga': 'pinga',
'sepinggan': 'pinggan',
'peminggang': 'pinggang',
'sepinggang': 'pinggang',
'sepinggangnya': 'pinggang',
'berpinggang': 'pinggang',
'peminggir': 'pinggir',
'peminggiran': 'pinggir',
'pinggiran': 'pinggir',
'pinggirannya': 'pinggir',
'meminggir': 'pinggir',
'meminggirkan': 'pinggir',
'meminggirkannya': 'pinggir',
'meminggiri': 'pinggir',
'kepinggiran': 'pinggir',
'terpinggirkan': 'pinggir',
'terpinggirkannya': 'pinggir',
'pingitan': 'pingit',
'pingitannya': 'pingit',
'memingit': 'pingit',
'berpingit': 'pingit',
'terpingkal-pingkal': 'pingkal',
'terpingkau-pingkau': 'pingkau',
'dipingpong': 'pingpong',
'terpinta': 'pinta',
'berpinta': 'pinta',
'terpintar': 'pintar',
'kepintaran': 'pintar',
'kepintarannya': 'pintar',
'kepintaranmu': 'pintar',
'kepioniran': 'pionir',
'kepionirannya': 'pionir',
'pemipaan': 'pipa',
'perpipaan': 'pipa',
'memipihkan': 'pipih',
'pipilan': 'pipil',
'memipil': 'pipil',
'pipisan': 'pipis',
'memipis': 'pipis',
'memipiskan': 'pipis',
'memipit': 'pipit',
'pipitan': 'pipit',
'memirau': 'pirau',
'berpirau': 'pirau',
'berpirau-pirau': 'pirau',
'memirik': 'pirik',
'piringan': 'piring',
'piringannya': 'piring',
'perpisangan': 'pisang',
'pisang-pisang': 'pisang',
'pisang-pisangan': 'pisang',
'memistol': 'pistol',
'pistol-pistolan': 'pistol',
'pisuhan': 'pisuh',
'berpita': 'pita',
'memitar': 'pitar',
'pitingan': 'piting',
'memiting': 'piting',
'memitingnya': 'piting',
'piting-memiting': 'piting',
'berpiutang': 'piutang',
'memiutangi': 'piutang',
'memiutangkan': 'piutang',
'keplastisan': 'plastis',
'memplombir': 'plombir',
'perploncoan': 'plonco',
'perploncoannya': 'plonco',
'memoces': 'poces',
'memocok': 'pocok',
'sepocong': 'pocong',
'memojok': 'pojok',
'memojokkan': 'pojok',
'memojokkannya': 'pojok',
'memojoki': 'pojok',
'memojokan': 'pojok',
'terpojok': 'pojok',
'terpojoknya': 'pojok',
'terpojokkan': 'pojok',
'terpojokan': 'pojok',
'pemojokan': 'pojok',
'berpokok': 'pokok',
'memokoki': 'pokok',
'memokokkan': 'pokok',
'memokrolkan': 'pokrol',
'pokrol-pokrolan': 'pokrol',
'berpola': 'pola',
'berpolah-polah': 'polah',
'polang-paling': 'polang',
'berpolemik': 'polemik',
'berpolemiknya': 'polemik',
'poleng-poleng': 'poleng',
'polesan': 'poles',
'polesannya': 'poles',
'pemoles': 'poles',
'pemolesan': 'poles',
'memoles': 'poles',
'memolesnya': 'poles',
'memoleskan': 'poles',
'memoleskannya': 'poles',
'memolesi': 'poles',
'berpoligami': 'poligami',
'pemolimeran': 'polimer',
'kepolisian': 'polisi',
'kepolisiannya': 'polisi',
'kepolisianlah': 'polisi',
'kepolisiani': 'polisi',
'memolok': 'polok',
'berpolok-polok': 'polok',
'polongan': 'polong',
'polong-polongan': 'polong',
'kepolosan': 'polos',
'kepolosannya': 'polos',
'poma-poma': 'poma',
'pompaan': 'pompa',
'memompa': 'pompa',
'memompanya': 'pompa',
'memompakan': 'pompa',
'pemompaan': 'pompa',
'pemompaannya': 'pompa',
'memondok': 'pondok',
'memondokkan': 'pondok',
'pondokan': 'pondok',
'pondokannya': 'pondok',
'pemondokan': 'pondok',
'pemondokannya': 'pondok',
'pondongan': 'pondong',
'memondong': 'pondong',
'memondongi': 'pondong',
'berpondong': 'pondong',
'terponggok': 'ponggok',
'berponi': 'poni',
'berponinya': 'poni',
'terpontang-panting': 'pontang-panting',
'berpontang-panting': 'pontang-panting',
'memontang-mantingkan': 'pontang-panting',
'memonten': 'ponten',
'popokan': 'popok',
'memopok': 'popok',
'memopokkan': 'popok',
'memopor': 'popor',
'kepopuleran': 'populer',
'kepopulerannya': 'populer',
'memopulerkan': 'populer',
'memopulerkannya': 'populer',
'memorahkan': 'porah',
'berporah-porah': 'porah',
'memorakporandakan': 'porak',
'memorak-perandakan': 'porak-peranda',
'memorak-porandakan': 'porak-poranda',
'berpori': 'pori',
'berporinya': 'pori',
'keporian': 'pori',
'memorot': 'porot',
'memoroti': 'porot',
'berpose': 'pose',
'berposenya': 'pose',
'berposelah': 'pose',
'memposer': 'poser',
'pemosisian': 'posisi',
'pemosisiannya': 'posisi',
'memosisikan': 'posisi',
'memosisikannya': 'posisi',
'kepositifan': 'positif',
'kepositifannya': 'positif',
'memositifkan': 'positif',
'keprabuan': 'prabu',
'keprajuritan': 'prajurit',
'pemrakarsa': 'prakarsa',
'pemrakarsanya': 'prakarsa',
'berprakarsa': 'prakarsa',
'memprakarsai': 'prakarsa',
'memprakarsainya': 'prakarsa',
'pemrakarsaan': 'prakarsa',
'prakiraan': 'prakira',
'prakiraannya': 'prakira',
'pemrakiraan': 'prakira',
'memprakirakan': 'prakira',
'berpraktik': 'praktik',
'mempraktikkan': 'praktik',
'mempraktikkannya': 'praktik',
'kepraktisan': 'praktis',
'kepraktisannya': 'praktis',
'sepraktis-praktisnya': 'praktis',
'kepramugaraan': 'pramugara',
'kepramukaan': 'pramuka',
'kepramukaannya': 'pramuka',
'mempraperadilankan': 'praperadilan',
'pemrasaran': 'prasaran',
'memprediksi': 'prediksi',
'memprediksinya': 'prediksi',
'memprediksikan': 'prediksi',
'memprediksikannya': 'prediksi',
'mengepres': 'pres',
'pengepresan': 'pres',
'mempresentasikan': 'presentasi',
'mempresentasikannya': 'presentasi',
'kepresidenan': 'presiden',
'kepresidenannya': 'presiden',
'kepresidenanan': 'presiden',
'kepresidenanku': 'presiden',
'kepresidenanmu': 'presiden',
'berprestasi': 'prestasi',
'berprestasinya': 'prestasi',
'berprestasilah': 'prestasi',
'berprestise': 'prestise',
'berpretensi': 'pretensi',
'kepriayian': 'priayi',
'mempribumikan': 'pribumi',
'berprihatin': 'prihatin',
'keprihatinan': 'prihatin',
'keprihatinannya': 'prihatin',
'keprihatinanlah': 'prihatin',
'keprihatinanan': 'prihatin',
'memprihatinkan': 'prihatin',
'memprihatinkannya': 'prihatin',
'memprihatinkanlah': 'prihatin',
'memprioritaskan': 'prioritas',
'memprioritaskannya': 'prioritas',
'mengemprit': 'prit',
'memprivatisasikan': 'privatisasi',
'pemroduksi': 'produksi',
'pemroduksinya': 'produksi',
'pemroduksian': 'produksi',
'berproduksi': 'produksi',
'berproduksinya': 'produksi',
'memproduksi': 'produksi',
'memproduksinya': 'produksi',
'memproduksikan': 'produksi',
'keproduktifan': 'produktif',
'keproduktifannya': 'produktif',
'berprofesi': 'profesi',
'pemrogram': 'program',
'pemrogramnya': 'program',
'pemrograman': 'program',
'memprogram': 'program',
'memprogramnya': 'program',
'memprogramkan': 'program',
'memprogramkannya': 'program',
'memprograman': 'program',
'terprogram': 'program',
'terprogramnya': 'program',
'terprogramlah': 'program',
'terprogramkan': 'program',
'pemrogramannya': 'program',
'memprosakan': 'prosa',
'pemrotes': 'protes',
'pemrotesnya': 'protes',
'pemrotesan': 'protes',
'memprotes': 'protes',
'memprotesnya': 'protes',
'memprotesi': 'protes',
'terprovokasi': 'provokasi',
'terprovokasinya': 'provokasi',
'memproyeksikan': 'proyeksi',
'memproyeksikannya': 'proyeksi',
'berpuak-puak': 'puak',
'berpuaka': 'puaka',
'kepualan': 'pual',
'berpual-pual': 'pual',
'terpublikasi': 'publikasi',
'terpublikasinya': 'publikasi',
'terpublikasikan': 'publikasi',
'terpublikasikannya': 'publikasi',
'pemublikasian': 'publikasi',
'memublikasikan': 'publikasi',
'memublikasikannya': 'publikasi',
'berpucuk': 'pucuk',
'memudikan': 'pudi',
'memudur': 'pudur',
'memudurkan': 'pudur',
'memuduri': 'pudur',
'berpugak-pugak': 'pugak',
'memugar': 'pugar',
'memugarnya': 'pugar',
'pemugar': 'pugar',
'pemugaran': 'pugar',
'memugari': 'pugar',
'pemugarannya': 'pugar',
'memugarkan': 'pugar',
'memugas': 'pugas',
'pugasan': 'pugas',
'pemugasan': 'pugas',
'memuingkan': 'puing',
'puing-puing': 'puing',
'puing-puingnya': 'puing',
'berpuing-puing': 'puing',
'berpuisi': 'puisi',
'pemuisian': 'puisi',
'memuisikan': 'puisi',
'kepujanggaan': 'pujangga',
'memujuk': 'pujuk',
'memujuknya': 'pujuk',
'terpujuk': 'pujuk',
'memujut': 'pujut',
'memukal': 'pukal',
'sepukal': 'pukal',
'memukang-mukang': 'pukang',
'berpukas': 'pukas',
'berpukas-pukas': 'pukas',
'pengepul': 'pul',
'pengepulnya': 'pul',
'pengepulkan': 'pul',
'puluhan': 'puluh',
'puluhannya': 'puluh',
'puluhanlah': 'puluh',
'puluhanan': 'puluh',
'sepuluh': 'puluh',
'sepuluhnya': 'puluh',
'sepuluhan': 'puluh',
'perpuluhan': 'puluh',
'persepuluhan': 'puluh',
'berpuluh-puluh': 'puluh',
'memulun-mulun': 'pulun',
'berpulun-pulun': 'pulun',
'pemulung': 'pulung',
'pemulungnya': 'pulung',
'pemulungan': 'pulung',
'memulung': 'pulung',
'memulungnya': 'pulung',
'memulungi': 'pulung',
'memulut': 'pulut',
'terpulut': 'pulut',
'pulut-pulut': 'pulut',
'memumpun': 'pumpun',
'memumpuni': 'pumpun',
'pumpunan': 'pumpun',
'terpumpun': 'pumpun',
'berpumpun': 'pumpun',
'pundi-pundi': 'pundi',
'pundi-pundinya': 'pundi',
'memundi-mundi': 'pundi',
'memundi-mundikan': 'pundi',
'memunggal': 'punggal',
'memunggung': 'punggung',
'memunggungi': 'punggung',
'memunggungkan': 'punggung',
'punggung-memunggung': 'punggung',
'memungkang': 'pungkang',
'pungkasan': 'pungkas',
'pemungkas': 'pungkas',
'pemungkasnya': 'pungkas',
'memungkasi': 'pungkas',
'pemungkur': 'pungkur',
'memungli': 'pungli',
'sepunguk': 'punguk',
'punjungan': 'punjung',
'memunjungi': 'punjung',
'memunjut': 'punjut',
'puntalan': 'puntal',
'memuntal': 'puntal',
'pemuntal': 'puntal',
'pemuntalan': 'puntal',
'berpuntal-puntal': 'puntalan',
'puntiran': 'puntir',
'memuntir': 'puntir',
'memuntirnya': 'puntir',
'memuntung': 'puntung',
'memuntungkan': 'puntung',
'berpunuk': 'punuk',
'sepupu': 'pupu',
'sepupunya': 'pupu',
'sepupuan': 'pupu',
'sepupuku': 'pupu',
'sepupumu': 'pupu',
'memupuh': 'pupuh',
'berpupuh': 'pupuh',
'memperpupuhkan': 'pupuh',
'pupuk hijau': 'memupuk',
'memupur': 'pupur',
'memupuri': 'pupur',
'berpupur': 'pupur',
'memupurkan': 'pupur',
'puputan': 'puput',
'memuput': 'puput',
'berpuput': 'puput',
'berpura-pura': 'pura-pura',
'berpura-puralah': 'pura-pura',
'kepura-puraan': 'pura-pura',
'kepurbaan': 'purba',
'kepurbakalaan': 'purbakala',
'berpuru': 'puru',
'berpuruan': 'puru',
'terpuruk': 'puruk',
'terpuruknya': 'puruk',
'terpuruklah': 'puruk',
'terpurukan': 'puruk',
'memurukkan': 'puruk',
'seterpuruk': 'puruk',
'memusakai': 'pusaka',
'berpusaka': 'pusaka',
'memusakakan': 'pusaka',
'memusar': 'pusar',
'pusaran': 'pusar',
'pusarannya': 'pusar',
'berpusar': 'pusar',
'berpusaran': 'pusar',
'pusar-pusar': 'pusar',
'berpusar-pusar': 'pusar',
'sepusat': 'pusat',
'berpusat': 'pusat',
'berpusatnya': 'pusat',
'berpusatkan': 'pusat',
'pemusatan': 'pusat',
'pemusatanan': 'pusat',
'memusatkan': 'pusat',
'memusatkannya': 'pusat',
'memusokan': 'puso',
'berpusu': 'pusu',
'berpusu-pusu': 'pusu',
'memusut': 'pusut',
'memusutkan': 'pusut',
'berputar lidah': 'putar lidah',
'puteran': 'puter',
'memuter': 'puter',
'berputih mata': 'putih mata',
'berputih tulang': 'putih tulang',
'berputik': 'putik',
'berputra': 'putra',
'keputraan': 'putra',
'memutrakan': 'putra',
'berputrakan': 'putra',
'berpuyan': 'puyan',
'memuyengkan': 'puyeng',
'memuyu-muyu': 'puyu',
'berqalam': 'qalam',
'mengqasar': 'qasar',
'rabaan': 'raba',
'meraba': 'raba',
'merabanya': 'raba',
'merabai': 'raba',
'peraba': 'raba',
'perabanya': 'raba',
'perabaan': 'raba',
'teraba': 'raba',
'terabanya': 'raba',
'perabaannya': 'raba',
'meraba-raba': 'raba',
'meraba-rabanya': 'raba',
'meraba-rabakan': 'raba',
'meraba-rabaku': 'raba',
'teraba-raba': 'raba',
'raba-rabaan': 'raba',
'merabak': 'rabak',
'terabak': 'rabak',
'merabas': 'rabas',
'merabat': 'rabat',
'merabet': 'rabet',
'merabit': 'rabit',
'merabuk': 'rabuk',
'merabuki': 'rabuk',
'perabun': 'rabun',
'merabuni': 'rabun',
'kerabunan': 'rabun',
'merabunkan': 'rabun',
'berabun-rabun': 'rabun',
'perabung': 'rabung',
'merabung': 'rabung',
'perabungan': 'rabung',
'merabut': 'rabut',
'meracak': 'racak',
'seracik': 'racik',
'meracik': 'racik',
'meraciknya': 'racik',
'meracikkan': 'racik',
'racikan': 'racik',
'racikannya': 'racik',
'peracikan': 'racik',
'peracikannya': 'racik',
'meracuh': 'racuh',
'rada-rada': 'rada',
'rada-radanya': 'rada',
'meradah': 'radah',
'meradai': 'radai',
'meradak': 'radak',
'meradakan': 'radak',
'beradak': 'radak',
'meradakkan': 'radak',
'meradikalkan': 'radikal',
'meradiokan': 'radio',
'meradukan': 'radu',
'meragang': 'ragang',
'ragangan': 'ragang',
'meragas': 'ragas',
'meraguk': 'raguk',
'teragung': 'ragung',
'merahap': 'rahap',
'perahap': 'rahap',
'merahapkan': 'rahap',
'berahasia': 'rahasia',
'berahasiakan': 'rahasia',
'kerahasiaan': 'rahasia',
'kerahasiaannya': 'rahasia',
'merahasiakan': 'rahasia',
'merahasiakannya': 'rahasia',
'rahasia-rahasiaan': 'rahasia',
'merahimi': 'rahim',
'kerahiman': 'rahim',
'kerahimannya': 'rahim',
'merais': 'rais',
'merajah': 'rajah',
'merajahi': 'rajah',
'merajalela': 'rajalela',
'merajalelanya': 'rajalela',
'rajaman': 'rajam',
'merajam': 'rajam',
'terajam': 'rajam',
'merajang': 'rajang',
'rajangan': 'rajang',
'merajuk': 'rajuk',
'merajuknya': 'rajuk',
'perajuk': 'rajuk',
'merajuki': 'rajuk',
'merakah': 'rakah',
'merakap': 'rakap',
'merakat': 'rakat',
'serakit': 'rakit',
'merakit': 'rakit',
'merakitnya': 'rakit',
'berakit': 'rakit',
'berakitan': 'rakit',
'rakitan': 'rakit',
'rakitannya': 'rakit',
'perakit': 'rakit',
'perakitnya': 'rakit',
'perakitan': 'rakit',
'perakitannya': 'rakit',
'berakit-rakit': 'rakit',
'meraksasa': 'raksasa',
'meraksasanya': 'raksasa',
'peraksi': 'raksi',
'meraksi': 'raksi',
'meraksikan': 'raksi',
'berakuk': 'rakuk',
'rakungan': 'rakung',
'merakut': 'rakut',
'merakyat': 'rakyat',
'merakyatnya': 'rakyat',
'merakyatlah': 'rakyat',
'merakyatkan': 'rakyat',
'perakyatan': 'rakyat',
'kerakyatan': 'rakyat',
'kerakyatannya': 'rakyat',
'meralat': 'ralat',
'meralatnya': 'ralat',
'meralip': 'ralip',
'beramah-tamah': 'ramah tamah',
'keramahtamahan': 'ramah tamah',
'keramahtamahannya': 'ramah tamah',
'keramahtamahanan': 'ramah tamah',
'teramai': 'ramai',
'keramaian': 'ramai',
'keramaiannya': 'ramai',
'keramaianan': 'ramai',
'meramaikan': 'ramai',
'meramaikannya': 'ramai',
'beramai-ramai': 'ramai',
'berambai': 'rambai',
'merambak': 'rambak',
'merambakkan': 'rambak',
'rambak tiongkok': 'rambak',
'meramban': 'ramban',
'rambanan': 'ramban',
'merambang': 'rambang',
'merambang-rambang': 'rambang',
'merambeh': 'rambeh',
'rambeh-rambeh': 'rambeh',
'meraminkan': 'ramin',
'merampai': 'rampai',
'rampaian': 'rampai',
'merampaikan': 'rampai',
'merampak': 'rampak',
'perampang': 'rampang',
'rampatan': 'rampat',
'merampat': 'rampat',
'perampatan': 'rampat',
'kerampatan': 'rampat',
'merampatkan': 'rampat',
'meramping': 'ramping',
'merampingnya': 'ramping',
'merampingkan': 'ramping',
'merampingkannya': 'ramping',
'merampok': 'rampok',
'merampoknya': 'rampok',
'merampokan': 'rampok',
'perampok': 'rampok',
'perampoknya': 'rampok',
'perampokkan': 'rampok',
'perampokan': 'rampok',
'perampokannya': 'rampok',
'perampungan': 'rampung',
'perampungannya': 'rampung',
'merampungkan': 'rampung',
'merampungkannya': 'rampung',
'berampus': 'rampus',
'merampus': 'rampus',
'meramu': 'ramu',
'meramunya': 'ramu',
'peramu': 'ramu',
'peramunya': 'ramu',
'peramuan': 'ramu',
'ramuan': 'ramu',
'ramuannya': 'ramu',
'reramuan': 'ramu',
'ramu-ramuan': 'ramu',
'meramus': 'ramus',
'beramus': 'ramus',
'meranap': 'ranap',
'meranca': 'ranca',
'merancakan': 'rancak',
'serancak': 'rancak',
'rancakan': 'rancak',
'merancak': 'rancak',
'kerancakan': 'rancak',
'kerancak-rancakan': 'rancak',
'rancaman': 'rancam',
'perancang': 'rancang',
'perancangnya': 'rancang',
'perancangan': 'rancang',
'berancang': 'rancang',
'rancangan': 'rancang',
'rancangannya': 'rancang',
'rancanganan': 'rancang',
'rancanganku': 'rancang',
'merancang': 'rancang',
'merancangnya': 'rancang',
'merancangkan': 'rancang',
'merancangkannya': 'rancang',
'merancangan': 'rancang',
'perancangannya': 'rancang',
'kerancuan': 'rancu',
'kerancuannya': 'rancu',
'merancukan': 'rancu',
'merancung': 'rancung',
'perancung': 'rancung',
'perancungan': 'rancung',
'meranda': 'randa',
'merandai': 'randai',
'berandai-randai': 'randai',
'merandak': 'randak',
'merandat': 'randat',
'merandatkan': 'randat',
'merandau': 'randau',
'merandek': 'randek',
'merandungkan': 'randung',
'merangah': 'rangah',
'merangai': 'rangai',
'merangak': 'rangak',
'meranggah': 'ranggah',
'meranggakkan': 'ranggak',
'meranggikan': 'ranggi',
'meranggitkan': 'ranggit',
'meranggul': 'ranggul',
'meranggung': 'ranggung',
'berangkaian': 'rangkai',
'serangkai': 'rangkai',
'serangkaian': 'rangkai',
'perangkai': 'rangkai',
'perangkainya': 'rangkai',
'perangkaian': 'rangkai',
'merangkai': 'rangkai',
'merangkainya': 'rangkai',
'merangkaikan': 'rangkai',
'merangkaikannya': 'rangkai',
'rangkaian': 'rangkai',
'rangkaiannya': 'rangkai',
'menyerangkaikan': 'rangkai',
'berangkai-rangkai': 'rangkai',
'merangkam': 'rangkam',
'merangkang': 'rangkang',
'merangket': 'rangket',
'merangkit': 'rangkit',
'merangkung': 'rangkung',
'rangkungan': 'rangkung',
'merangkus': 'rangkus',
'merangkut': 'rangkut',
'merangum': 'rangum',
'seranjang': 'ranjang',
'seranjangnya': 'ranjang',
'berseranjang': 'ranjang',
'meranjangkan': 'ranjang',
'keranjingan': 'ranjing',
'keranjingannya': 'ranjing',
'meransum': 'ransum',
'berantam': 'rantam',
'berantamlah': 'rantam',
'merantas': 'rantas',
'perantau': 'rantau',
'perantauan': 'rantau',
'merantau': 'rantau',
'merantaunya': 'rantau',
'merantaulah': 'rantau',
'serantau': 'rantau',
'perantauannya': 'rantau',
'perantauanmu': 'rantau',
'meranting': 'ranting',
'beranting': 'ranting',
'merantuk': 'rantuk',
'merantukkan': 'rantuk',
'meranyah': 'ranyah',
'meranyau': 'ranyau',
'meranyun': 'ranyun',
'merapah': 'rapah',
'merapai': 'rapai',
'merapal': 'rapal',
'merapalkan': 'rapal',
'merapik': 'rapik',
'merapikkan': 'rapik',
'raporan': 'rapor',
'meraporkan': 'rapor',
'merapu': 'rapu',
'merapukan': 'rapu',
'perapuh': 'rapuh',
'perapuhan': 'rapuh',
'kerapuhan': 'rapuh',
'kerapuhannya': 'rapuh',
'merapuhkan': 'rapuh',
'berapun': 'rapun',
'merapun': 'rapun',
'merapung': 'rapung',
'merapungkan': 'rapung',
'merapus': 'rapus',
'merarai': 'rarai',
'perarai': 'rarai',
'merarasi': 'raras',
'serasam': 'rasam',
'berasan': 'rasan',
'merasani': 'rasan',
'perasanan': 'rasan',
'perasanannya': 'rasan',
'merasi': 'rasi',
'merasikan': 'rasi',
'berasian': 'rasian',
'merasiankan': 'rasian',
'berasio': 'rasio',
'kerasionalan': 'rasional',
'merasionalkan': 'rasional',
'merasionalisasi': 'rasionalisasi',
'merasionalisasikan': 'rasionalisasi',
'merasionalisasikannya': 'rasionalisasi',
'kerasulan': 'rasul',
'kerasulannya': 'rasul',
'meratah': 'ratah',
'meratib': 'ratib',
'meratibkan': 'ratib',
'meratifikasi': 'ratifikasi',
'meratifikasinya': 'ratifikasi',
'meraum': 'raum',
'meraun': 'raun',
'raun-raun': 'raun',
'rautan': 'raut',
'meraut': 'raut',
'berawa': 'rawa',
'berawa-rawa': 'rawa',
'merawai': 'rawai',
'merawaikan': 'rawai',
'merawak': 'rawak',
'serawan': 'rawan',
'merawan': 'rawan',
'kerawanan': 'rawan',
'kerawanannya': 'rawan',
'kerawananan': 'rawan',
'merawankan': 'rawan',
'merawang': 'rawang',
'perawi': 'rawi',
'perawinya': 'rawi',
'merawi': 'rawi',
'merawikan': 'rawi',
'merawit': 'rawit',
'kerawitan': 'rawit',
'pengrawit': 'rawit',
'rayahan': 'rayah',
'merayah': 'rayah',
'merayahi': 'rayah',
'merayang': 'rayang',
'merayap': 'rayap',
'merayapnya': 'rayap',
'merayapi': 'rayap',
'rayapan': 'rayap',
'terayap-rayap': 'rayap',
'perayonan': 'rayon',
'merealisasi': 'realisasi',
'merealisasikan': 'realisasi',
'merealisasikannya': 'realisasi',
'merealisasian': 'realisasi',
'berebab': 'rebab',
'merebankan': 'reban',
'berebana': 'rebana',
'rebas-rebas': 'rebas',
'merebat': 'rebat',
'merebeh': 'rebeh',
'rebekan': 'rebek',
'berebesan': 'rebes',
'merebuk': 'rebuk',
'merebung': 'rebung',
'merecak': 'recak',
'recehan': 'receh',
'recehannya': 'receh',
'perecik': 'recik',
'merecik': 'recik',
'recikan': 'recik',
'merecikkan': 'recik',
'perecok': 'recok',
'merecok': 'recok',
'merecokkan': 'recok',
'merecoki': 'recok',
'merecokinya': 'recok',
'kerecokan': 'recok',
'merecup': 'recup',
'meredah': 'redah',
'meredahkan': 'redah',
'meredih': 'redih',
'peredih': 'redih',
'meredik': 'redik',
'mereduksi': 'reduksi',
'mereduksinya': 'reduksi',
'meredup': 'redup',
'meredupnya': 'redup',
'meredupkan': 'redup',
'meredupkannya': 'redup',
'keredupan': 'redup',
'redep-redup': 'redup',
'meredusir': 'redusir',
'meredut': 'redut',
'mereekspor': 'reekspor',
'merefleksikan': 'refleksi',
'merefleksikannya': 'refleksi',
'terefleksikan': 'refleksi',
'berefraksi': 'refraksi',
'meregah': 'regah',
'meregang': 'regang',
'meregangnya': 'regang',
'meregangkan': 'regang',
'meregangkannya': 'regang',
'regangan': 'regang',
'regangannya': 'regang',
'peregangan': 'regang',
'peregangannya': 'regang',
'berseregang': 'seregang',
'beregang-regang': 'regang',
'meregas': 'regas',
'meregat': 'regat',
'keregenan': 'regen',
'sereguk': 'reguk',
'mereguk': 'reguk',
'mereguknya': 'reguk',
'meregukan': 'reguk',
'meregup': 'regup',
'merehab': 'rehab',
'merehabnya': 'rehab',
'merehabilitasi': 'rehabilitasi',
'merehabilitasinya': 'rehabilitasi',
'merehabilitasikan': 'rehabilitasi',
'reja-reja': 'reja',
'merejah': 'rejah',
'perejah': 'rejah',
'merejahkan': 'rejah',
'merejan': 'rejan',
'merejang': 'rejang',
'perejang': 'rejang',
'serejang': 'rejang',
'merejeng': 'rejeng',
'merejuk': 'rejuk',
'mereka cipta': 'reka cipta',
'perekam': 'rekam',
'perekamnya': 'rekam',
'perekaman': 'rekam',
'rekaman': 'rekam',
'rekamannya': 'rekam',
'rekamanlah': 'rekam',
'rekamanan': 'rekam',
'rekamanku': 'rekam',
'merekam': 'rekam',
'merekamnya': 'rekam',
'merekamlah': 'rekam',
'merekamkan': 'rekam',
'merekaman': 'rekam',
'merekammu': 'rekam',
'perekamannya': 'rekam',
'perekamanan': 'rekam',
'merekan': 'rekan',
'berekan': 'rekan',
'berekanan': 'rekan',
'rekanan': 'rekan',
'rekanannya': 'rekan',
'rekananan': 'rekan',
'perekayasa': 'rekayasa',
'perekayasaan': 'rekayasa',
'merekayasa': 'rekayasa',
'merekayasanya': 'rekayasa',
'rekenan': 'reken',
'mereken': 'reken',
'merekes': 'rekes',
'mereklamasikan': 'reklamasi',
'merekomendasi': 'rekomendasi',
'merekomendasinya': 'rekomendasi',
'merekomendasikan': 'rekomendasi',
'merekomendasikannya': 'rekomendasi',
'merekonstruksi': 'rekonstruksi',
'merekonstruksinya': 'rekonstruksi',
'merekonstruksikan': 'rekonstruksi',
'berekreasi': 'rekreasi',
'merekrut': 'rekrut',
'merekrutnya': 'rekrut',
'merekruti': 'rekrut',
'merekrutku': 'rekrut',
'merekrutmu': 'rekrut',
'perekrutan': 'rekrut',
'perekrutannya': 'rekrut',
'merelang': 'relang',
'merelas': 'relas',
'merelevansi': 'relevansi',
'merelevansikan': 'relevansi',
'pereli': 'reli',
'merelokasi': 'relokasi',
'merelokasinya': 'relokasi',
'merelokasikan': 'relokasi',
'merelokasikannya': 'relokasi',
'bereluk': 'reluk',
'merelung': 'relung',
'mengerem': 'rem',
'mengeremnya': 'rem',
'keremahan': 'remah',
'meremahkan': 'remah',
'remah-remah': 'remah',
'remah-remahnya': 'remah',
'remah-remahan': 'remah',
'meremah-remah': 'remah',
'peremajaan': 'remaja',
'peremajaannya': 'remaja',
'meremajakan': 'remaja',
'meremajakannya': 'remaja',
'meremas': 'remas',
'meremasnya': 'remas',
'meremas-remas': 'remas',
'meremas-remasnya': 'remas',
'merembah': 'rembah',
'rembah-rembah': 'rembah',
'rembah-rembih': 'rembah',
'merembet': 'rembet',
'merembetnya': 'rembet',
'merembetkan': 'rembet',
'merembih': 'rembih',
'berembuk': 'rembuk',
'berembuklah': 'rembuk',
'rembukan': 'rembuk',
'perembukan': 'rembuk',
'merembukkan': 'rembuk',
'merembukkannya': 'rembuk',
'memperembukkan': 'rembuk',
'berembut-rembut': 'rembut',
'terembut-rembut': 'rembut',
'meremet': 'remet',
'merempa': 'rempa',
'merempah': 'rempah',
'merempahi': 'rempah',
'rempah-rempah': 'rempah',
'rempah-rempahnya': 'rempah',
'rempah-rempahan': 'rempah',
'merempah-rempah': 'rempah',
'merempah-rempahi': 'rempah',
'serempak': 'rempak',
'serempaknya': 'rempak',
'berempak': 'rempak',
'menyerempak': 'serempak',
'menyerempakkan': 'serempak',
'peremuk': 'remuk',
'peremukan': 'remuk',
'meremukkan': 'remuk',
'meremukkannya': 'remuk',
'terencah': 'rencah',
'merencah': 'rencah',
'perencah': 'rencah',
'merencam': 'rencam',
'terencat': 'rencat',
'berenceng': 'renceng',
'serenceng': 'renceng',
'rencengan': 'renceng',
'merendang': 'rendang',
'perendangan': 'rendang',
'berendeng': 'rendeng',
'merendengkan': 'rendeng',
'terendong': 'rendong',
'merenek': 'renek',
'merengap': 'rengap',
'merengas': 'rengas',
'merengat': 'rengat',
'merengatkan': 'rengat',
'merengeh': 'rengeh',
'merengeng-rengeng': 'rengeng',
'merengkah': 'rengkah',
'perengkahan': 'rengkah',
'merengkeh': 'rengkeh',
'merengket': 'rengket',
'merengkuh': 'rengkuh',
'merengkuhnya': 'rengkuh',
'merengsa': 'rengsa',
'berengsaan': 'rengsa',
'perengut': 'rengut',
'merengut': 'rengut',
'merengutkan': 'rengut',
'merenik-renik': 'renik',
'merenjeng': 'renjeng',
'merenjis': 'renjis',
'merenjiskan': 'renjis',
'merenovasi': 'renovasi',
'merenovasinya': 'renovasi',
'merenta-renta': 'renta',
'merentak': 'rentak',
'merentakan': 'rentak',
'terentak': 'rentak',
'serentak': 'rentak',
'serentaknya': 'rentak',
'menyerentakkan': 'rentak',
'merentan': 'rentan',
'merentankan': 'rentan',
'kerentanan': 'rentan',
'kerentanannya': 'rentan',
'kerentananan': 'rentan',
'merentap': 'rentap',
'merentapkan': 'rentap',
'merentas': 'rentas',
'rentengan': 'renteng',
'serenteng': 'renteng',
'serentengan': 'renteng',
'merenteng': 'renteng',
'berenteng-renteng': 'renteng',
'berentet': 'rentet',
'berentetan': 'rentet',
'rentetan': 'rentet',
'rentetannya': 'rentet',
'merentikan': 'renti',
'merentik': 'rentik',
'berenyah': 'renyah',
'merenyah': 'renyah',
'merenyahnya': 'renyah',
'kerenyahan': 'renyah',
'kerenyahannya': 'renyah',
'renyai-renyai': 'renyai',
'merenyai-renyai': 'renyai',
'merenyeh': 'renyeh',
'merenyuk': 'renyuk',
'serenyuk': 'renyuk',
'merenyukkan': 'renyuk',
'merenyut': 'renyut',
'merepang': 'repang',
'mereparasi': 'reparasi',
'mereparasinya': 'reparasi',
'terepas': 'repas',
'keterepasan': 'repas',
'merepatriasi': 'repatriasi',
'merepatriasikan': 'repatriasi',
'merepet': 'repet',
'perepet': 'repet',
'repihan': 'repih',
'serepih': 'repih',
'mereportasekan': 'reportase',
'kerepotan': 'repot',
'kerepotannya': 'repot',
'kerepotanlah': 'repot',
'merepotkan': 'repot',
'merepotkannya': 'repot',
'merepotkanmu': 'repot',
'repot-repot': 'repot',
'repot-repotlah': 'repot',
'mereproduksi': 'reproduksi',
'mereproduksinya': 'reproduksi',
'repuh-repuh': 'repuh',
'mererak': 'rerak',
'bererakan': 'rerak',
'rerotan': 'rerot',
'mererot': 'rerot',
'seresam': 'resam',
'meresan': 'resan',
'meresek-resek': 'resek',
'meresepkan': 'resep',
'meresepkannya': 'resep',
'keresidenan': 'residen',
'meresik': 'resik',
'keresikan': 'resik',
'peresmian': 'resmi',
'peresmiannya': 'resmi',
'keresmian': 'resmi',
'keresmiannya': 'resmi',
'meresmikan': 'resmi',
'meresmikannya': 'resmi',
'meresosialisasi': 'resosialisasi',
'merespons': 'respons',
'meresponsnya': 'respons',
'meresponslah': 'respons',
'meresponsi': 'respons',
'meresponsmu': 'respons',
'merestorasi': 'restorasi',
'merestorasinya': 'restorasi',
'merestrukturisasi': 'restrukturisasi',
'merestrukturisasinya': 'restrukturisasi',
'merestrukturisasikan': 'restrukturisasi',
'meresumekan': 'resume',
'peretas': 'retas',
'peretasnya': 'retas',
'peretaslah': 'retas',
'peretasan': 'retas',
'meretas': 'retas',
'meretasnya': 'retas',
'meretaskan': 'retas',
'peretasannya': 'retas',
'meretek': 'retek',
'meretih': 'retih',
'meretur': 'retur',
'merevisi': 'revisi',
'merevisinya': 'revisi',
'merewak': 'rewak',
'merewaknya': 'rewak',
'kerewelan': 'rewel',
'kerewelannya': 'rewel',
'merewet': 'rewet',
'keriaan': 'ria',
'keriaannya': 'ria',
'beria-ria': 'ria',
'beriak': 'riak',
'beriak-riak': 'riak',
'meriap': 'riap',
'meriapkan': 'riap',
'ribaan': 'riba',
'meriba': 'riba',
'rica-rica': 'rica',
'mericau': 'ricau',
'mericik': 'ricik',
'kericuhan': 'ricuh',
'kericuhannya': 'ricuh',
'meridai': 'rida',
'berigi-rigi': 'rigi-rigi',
'berihat': 'rihat',
'merikuhkan': 'rikuh',
'merilis': 'rilis',
'merilisnya': 'rilis',
'meriliskan': 'rilis',
'merilisi': 'rilis',
'berima': 'rima',
'merimaskan': 'rimas',
'perimba': 'rimba',
'perimbakan': 'rimba',
'merimba': 'rimba',
'merimbas': 'rimbas',
'merimbun': 'rimbun',
'merimbunkan': 'rimbun',
'merimbuni': 'rimbun',
'kerimbunan': 'rimbun',
'kerimbunannya': 'rimbun',
'serimis': 'rimis',
'merimpuhkan': 'rimpuh',
'merimpung': 'rimpung',
'merinai': 'rinai',
'berinaian': 'rinai',
'merinaikan': 'rinai',
'rinai-rinai': 'rinai',
'perincis': 'rincis',
'rincisan': 'rincis',
'merincis': 'rincis',
'perincisan': 'rincis',
'merincukan': 'rincu',
'perindang': 'rindang',
'perindangan': 'rindang',
'merindang': 'rindang',
'merindangkan': 'rindang',
'merindangi': 'rindang',
'merinding': 'rinding',
'merindingnya': 'rinding',
'merindingkan': 'rinding',
'perindu': 'rindu',
'perindukan': 'rindu',
'merindu': 'rindu',
'merindukan': 'rindu',
'merindukannya': 'rindu',
'merindui': 'rindu',
'rinduan': 'rindu',
'kerinduan': 'rindu',
'kerinduannya': 'rindu',
'kerinduanku': 'rindu',
'kerinduanmu': 'rindu',
'merindukanku': 'rindu',
'merindukanmu': 'rindu',
'meringgiti': 'ringgit',
'beringgit-ringgit': 'ringgit',
'meringih': 'ringih',
'meringik': 'ringik',
'meringis': 'ringis',
'meringkai': 'ringkai',
'meringkaikan': 'ringkai',
'ringkasan': 'ringkas',
'ringkasannya': 'ringkas',
'meringkaskan': 'ringkas',
'meringking': 'ringking',
'meringkuk': 'ringkuk',
'meringkuknya': 'ringkuk',
'meringkuklah': 'ringkuk',
'ringkukan': 'ringkuk',
'meringkukkan': 'ringkuk',
'dalam ringkuk': 'ringkuk',
'meringkus': 'ringkus',
'meringkusnya': 'ringkus',
'meringsing': 'ringsing',
'merintas': 'rintas',
'berintik-rintik': 'rintik',
'merintik-rintik': 'rintik-rintik',
'merisak': 'risak',
'merisaknya': 'risak',
'periset': 'riset',
'perisetnya': 'riset',
'meriset': 'riset',
'merisetnya': 'riset',
'merisik': 'risik',
'risikan': 'risik',
'merisikkan': 'risik',
'meritul': 'ritul',
'meriung': 'riung',
'riungan': 'riung',
'beriwayat': 'riwayat',
'keriwayatan': 'riwayat',
'meriwayatkan': 'riwayat',
'robekan': 'robek',
'robekannya': 'robek',
'merobek': 'robek',
'merobeknya': 'robek',
'merobekkan': 'robek',
'merobeki': 'robek',
'merobekan': 'robek',
'perobek': 'robek',
'perobekan': 'robek',
'merobek-robek': 'robek',
'merobek-robeknya': 'robek',
'merobok': 'robok',
'bersirobok': 'robok',
'merobot': 'robot',
'perobotan': 'robot',
'beroda': 'roda',
'berodanya': 'roda',
'berodi': 'rodi',
'merodong': 'rodong',
'merodongkan': 'rodong',
'merogoh': 'rogoh',
'merogohnya': 'rogoh',
'merogohkan': 'rogoh',
'merogok': 'rogok',
'merogol': 'rogol',
'merogolnya': 'rogol',
'kerohanian': 'rohani',
'kerohaniannya': 'rohani',
'rojengan': 'rojeng',
'merojeng': 'rojeng',
'merojol': 'rojol',
'meroket': 'roket',
'meroketnya': 'roket',
'meroketkan': 'roket',
'meroketi': 'roket',
'peroketan': 'roket',
'seroma': 'roma',
'keromantisan': 'romantis',
'keromantisannya': 'romantis',
'meromantisisme': 'romantisisme',
'merombak': 'rombak',
'merombaknya': 'rombak',
'merombakan': 'rombak',
'perombakan': 'rombak',
'perombakannya': 'rombak',
'perombakanan': 'rombak',
'rombengan': 'rombeng',
'merombengkan': 'rombeng',
'merombong': 'rombong',
'rombongan': 'rombong',
'rombongannya': 'rombong',
'rombongani': 'rombong',
'meromet': 'romet',
'meromok': 'romok',
'rompang-romping': 'rompang',
'merompongkan': 'rompong',
'meromusakan': 'romusa',
'berona': 'rona',
'perona': 'rona',
'teronce': 'ronce',
'meronce': 'ronce',
'peroncean': 'ronce',
'beroncet-roncet': 'roncet',
'merondok': 'rondok',
'berondok': 'rondok',
'merondokkan': 'rondok',
'meroneo': 'roneo',
'merongga': 'rongga',
'berongga': 'rongga',
'meronggeng': 'ronggeng',
'keronggengan': 'ronggeng',
'meronggong': 'ronggong',
'merongkok': 'rongkok',
'berongkol': 'rongkol',
'serongkol': 'rongkol',
'merongos': 'rongos',
'rongkong': 'rongos',
'perongos': 'rongos',
'perongrong': 'rongrong',
'perongrongan': 'rongrong',
'merongrong': 'rongrong',
'merongrongnya': 'rongrong',
'merongseng': 'rongseng',
'rongsokan': 'rongsok',
'rongsokannya': 'rongsok',
'meronta': 'ronta',
'meronta-ronta': 'ronta',
'merontgen': 'rontgen',
'kerontokan': 'rontok',
'kerontokannya': 'rontok',
'merontokkan': 'rontok',
'merontokkannya': 'rontok',
'meronyeh': 'ronyeh',
'meronyok': 'ronyok',
'merorod': 'rorod',
'merosok': 'rosok',
'rosokan': 'rosok',
'merosokkan': 'rosok',
'berotasi': 'rotasi',
'merotok': 'rotok',
'merowot': 'rowot',
'meroyak': 'royak',
'keroyalan': 'royal',
'beroyal-royal': 'royal',
'royal-royalan': 'royal',
'meroyan': 'royan',
'meroyer': 'royer',
'merua': 'rua',
'meruanya': 'rua',
'meruakan': 'ruak',
'seruah': 'ruah',
'meruah': 'ruah',
'meruahnya': 'ruah',
'seperuah': 'ruah',
'meruahkan': 'ruah',
'meruak': 'ruak',
'meruaknya': 'ruak',
'ruak-ruak': 'ruak',
'meruang': 'ruang',
'meruangkan': 'ruang',
'ruangan': 'ruang',
'ruangannya': 'ruang',
'ruanganlah': 'ruang',
'ruanganan': 'ruang',
'ruanganku': 'ruang',
'ruanganmu': 'ruang',
'meruap': 'ruap',
'meruapnya': 'ruap',
'meruapkan': 'ruap',
'meruapan': 'ruap',
'meruap-ruap': 'ruap',
'seruas': 'ruas',
'peruasan': 'ruas',
'beruas-ruas': 'ruas',
'meruban': 'ruban',
'merubu': 'rubu',
'merubu-rubu': 'rubu',
'merubung': 'rubung',
'merubungi': 'rubung',
'merudal': 'rudal',
'merudalnya': 'rudal',
'merudu': 'rudu',
'meruing': 'ruing',
'teruit': 'uit',
'merujah': 'rujah',
'ruji-ruji': 'ruji',
'meruku': 'ruku',
'reruku': 'ruku',
'ruku-ruku': 'ruku',
'merukuk': 'rukuk',
'kerukunan': 'rukun',
'kerukunannya': 'rukun',
'kerukunanan': 'rukun',
'merukunkan': 'rukun',
'serumah': 'rumah',
'serumahnya': 'rumah',
'berumah': 'rumah',
'berumahkan': 'rumah',
'perumahan': 'rumah',
'perumahannya': 'rumah',
'perumahanlah': 'rumah',
'perumahanan': 'rumah',
'merumahkan': 'rumah',
'merumahkannya': 'rumah',
'memperumahkan': 'rumah',
'rumah-rumahan': 'rumah',
'rumah-rumahannya': 'rumah',
'menyerumahkan': 'rumah',
'merumahsakitkan': 'rumah sakit',
'berumah tangga': 'rumah tangga',
'kerumahtanggaan': 'rumah tangga',
'kerumahtanggaannya': 'rumah tangga',
'berumbai-rumbai': 'rumbai',
'merumbu': 'rumbu',
'rumitan': 'rumit',
'kerumitan': 'rumit',
'kerumitannya': 'rumit',
'merumitkan': 'rumit',
'merumitkannya': 'rumit',
'merumpi': 'rumpi',
'kerumpilan': 'rumpil',
'merumponkan': 'rumpon',
'berumpun': 'rumpun',
'serumpun': 'rumpun',
'serumpunnya': 'rumpun',
'merumpun': 'rumpun',
'berrumpun-rumpun': 'rumpun',
'merumput': 'rumput',
'merumputnya': 'rumput',
'merumputkan': 'rumput',
'merumputkannya': 'rumput',
'merumputi': 'rumput',
'rerumputan': 'rumput',
'rerumputannya': 'rumput',
'perumputan': 'rumput',
'rumput-rumputan': 'rumput',
'merumrum': 'rumrum',
'merumuk': 'rumuk',
'merumung': 'rumung',
'runding-merunding': 'berunding',
'rundukan': 'runduk',
'merunduk': 'runduk',
'merunduklah': 'runduk',
'merundukkan': 'runduk',
'merundukan': 'runduk',
'merunggas': 'runggas',
'berunggas-runggas': 'runggas',
'rungguhan': 'rungguh',
'merungguh': 'rungguh',
'merungguhkan': 'rungguh',
'merunggut': 'runggut',
'merungkau': 'rungkau',
'kerungkuhan': 'rungkuh',
'merungkup': 'rungkup',
'merungus': 'rungus',
'merungus-rungus': 'rungus',
'merunjam': 'runjam',
'merunjang': 'runjang',
'merunjau': 'runjau',
'merunjung': 'runjung',
'meruntas': 'runtas',
'merunti': 'runti',
'meruntih': 'runtih',
'runtunan': 'runtun',
'meruntun': 'runtun',
'meruntunkan': 'runtun',
'beruntun': 'untun',
'beruntunnya': 'untun',
'beruntun-runtun': 'runtun',
'beruntutan': 'runtutan',
'perunut': 'runut',
'perunutan': 'runut',
'runutan': 'runut',
'runutannya': 'runut',
'merunut': 'runut',
'merunutnya': 'runut',
'merunutkan': 'runut',
'merunuti': 'runut',
'merunyamkan': 'runyam',
'merunyut': 'runyut',
'meruok': 'ruok',
'serupiah': 'rupiah',
'merurut': 'rurut',
'merusuh': 'rusuh',
'merusuhkan': 'rusuh',
'merusuhi': 'rusuh',
'perusuh': 'rusuh',
'perusuhnya': 'rusuh',
'perusuhan': 'rusuh',
'berusuh': 'rusuh',
'berusuhan': 'rusuh',
'kerusuhan': 'rusuh',
'kerusuhannya': 'rusuh',
'kerusuhanlah': 'rusuh',
'kerusuhanan': 'rusuh',
'memperusuh': 'rusuh',
'merusuk': 'rusuk',
'kerutinan': 'rutin',
'merutinkan': 'rutin',
'merutuk': 'rutuk',
'merutuki': 'rutuk',
'ruwatan': 'ruwat',
'ruwatannya': 'ruwat',
'meruwat': 'ruwat',
'keruwetan': 'ruwet',
'keruwetannya': 'ruwet',
'meruwetkan': 'ruwet',
'meruyak': 'ruyak',
'meruyaknya': 'ruyak',
'meruyupkan': 'ruyup',
'sesaat': 'saat',
'sesaatnya': 'saat',
'menyaba': 'saba',
'bersaba': 'saba',
'menyabak': 'sabak',
'saban-saban': 'saban',
'bersabar': 'sabar',
'bersabarnya': 'sabar',
'bersabarlah': 'sabar',
'penyabar': 'sabar',
'penyabaran': 'sabar',
'tersabar': 'sabar',
'kesabaran': 'sabar',
'kesabarannya': 'sabar',
'kesabaranlah': 'sabar',
'kesabaranku': 'sabar',
'kesabaranmu': 'sabar',
'menyabarkan': 'sabar',
'mempersabar': 'sabar',
'menyabat': 'sabat',
'bersabda': 'sabda',
'menyabdakan': 'sabda',
'sabetan': 'sabet',
'sabetannya': 'sabet',
'penyabet': 'sabet',
'penyabetan': 'sabet',
'menyabet': 'sabet',
'menyabetnya': 'sabet',
'menyabetkan': 'sabet',
'menyabetkannya': 'sabet',
'tersabet': 'sabet',
'sabitan': 'sabit',
'penyabit': 'sabit',
'menyabit': 'sabit',
'penyabitan': 'sabit',
'menyabitkan': 'sabit',
'menyablon': 'sablon',
'penyablon': 'sablon',
'penyablonan': 'sablon',
'sabotan': 'sabot',
'penyabot': 'sabot',
'penyabotan': 'sabot',
'menyabot': 'sabot',
'bersabuk': 'sabuk',
'sabuk jingga': 'sabuk',
'menyabun': 'sabun',
'menyabuni': 'sabun',
'bersabun': 'sabun',
'menyabuninya': 'sabun',
'penyabunan': 'sabun',
'penyabunanan': 'sabun',
'menyabunkan': 'sabun',
'sabungan': 'sabung',
'penyabung': 'sabung',
'penyabungnya': 'sabung',
'penyabungan': 'sabung',
'menyabung': 'sabung',
'tersabung': 'sabung',
'bersabung': 'sabung',
'persabungan': 'sabung',
'menyabungkan': 'sabung',
'sabung-menyabung': 'sabung',
'tersabur': 'sabur',
'menyabur': 'sabur',
'menyaburkan': 'sabur',
'kesadahan': 'sadah',
'bersadai': 'sadai',
'tersadai': 'sadai',
'menyadaikan': 'sadai',
'sadang sading': 'sadang',
'sadapan': 'sadap',
'sadapannya': 'sadap',
'tersadap': 'sadap',
'tersadapnya': 'sadap',
'menyadap': 'sadap',
'menyadapnya': 'sadap',
'menyadapan': 'sadap',
'penyadap': 'sadap',
'penyadapnya': 'sadap',
'penyadapan': 'sadap',
'penyadapannya': 'sadap',
'menyadau': 'sadau',
'bersadau': 'sadau',
'menyadikkan': 'sadik',
'kesadisan': 'sadis',
'kesadisannya': 'sadis',
'bersado': 'sado',
'sado masokis': 'sado',
'menyadran': 'sadran',
'saduran': 'sadur',
'penyadur': 'sadur',
'penyaduran': 'sadur',
'menyadur': 'sadur',
'menyadurnya': 'sadur',
'bersaf-saf': 'saf',
'bersafar': 'safar',
'bersafari': 'safari',
'menyagang': 'sagang',
'tersagang': 'sagang',
'menyagar': 'sagar',
'bersagar': 'sagar',
'sesagon': 'sagon',
'menyagu': 'sagu',
'kesahan': 'sah',
'pengesahan': 'sah',
'pengesahannya': 'sah',
'mengesahkankan': 'sah',
'bersahaja': 'sahaja',
'bersahajanya': 'sahaja',
'menyahaja': 'sahaja',
'kesahajaan': 'sahaja',
'kesahajaannya': 'sahaja',
'menyahajakan': 'sahaja',
'mempersahajakan': 'sahaja',
'menyahap': 'sahap',
'bersahap': 'sahap',
'kesahihan': 'sahih',
'kesahihannya': 'sahih',
'penyahihan': 'sahih',
'menyahihkan': 'sahih',
'sesajen': 'sajen',
'sajian': 'saji',
'sajiannya': 'saji',
'tersaji': 'saji',
'tersajinya': 'saji',
'tersajilah': 'saji',
'tersajikan': 'saji',
'penyaji': 'saji',
'penyajinya': 'saji',
'penyajikan': 'saji',
'penyajian': 'saji',
'bersaji': 'saji',
'penyajiannya': 'saji',
'menyajikan': 'saji',
'menyajikannya': 'saji',
'saji-sajian': 'saji',
'menyakal': 'sakal',
'sakapan': 'sakap',
'menyakap': 'sakap',
'menyakapi': 'sakap',
'penyakap': 'sakap',
'penyakapan': 'sakap',
'menyakar': 'sakar',
'penyakar': 'sakar',
'tersakat': 'sakat',
'penyakat': 'sakat',
'menyakatkan': 'sakat',
'kesakralan': 'sakral',
'kesakralannya': 'sakral',
'bersaksi': 'saksi',
'bersaksinya': 'saksi',
'bersaksilah': 'saksi',
'kesaksian': 'saksi',
'kesaksiannya': 'saksi',
'kesaksianku': 'saksi',
'penyaksian': 'saksi',
'menyaksikan': 'saksi',
'menyaksikannya': 'saksi',
'menyaksikanku': 'saksi',
'menyaksikanmu': 'saksi',
'mempersaksikan': 'saksi',
'tersaku': 'saku',
'saku-saku': 'saku',
'menyakukan': 'saku',
'penyalahartian': 'salah arti',
'menyalahartikan': 'salah arti',
'menyalahartikannya': 'salah arti',
'salakan': 'salak',
'menyalak': 'salak',
'menyalakkan': 'salak',
'penyalak': 'salak',
'menyalang': 'salang',
'bersalat': 'salat',
'menyalatkan': 'salat',
'menyalatkannya': 'salat',
'kesalehan': 'saleh',
'kesalehannya': 'saleh',
'menyalep': 'salep',
'penyalib': 'salib',
'penyaliban': 'salib',
'menyalib': 'salib',
'menyalibnya': 'salib',
'menyalibkan': 'salib',
'penyalibannya': 'salib',
'kesalingan': 'saling',
'menyalip': 'salip',
'menyalipnya': 'salip',
'menyalipku': 'salip',
'menyalipmu': 'salip',
'bersalip-salipan': 'salip',
'menyalju': 'salju',
'bersalju': 'salju',
'bersaljunya': 'salju',
'pesalto': 'salto',
'bersalto': 'salto',
'bersaluir': 'saluir',
'menyaluir': 'saluir',
'bersaluk': 'saluk',
'bersalung': 'salung',
'salutan': 'salut',
'tersalut': 'salut',
'bersalut': 'salut',
'penyalut': 'salut',
'menyalut': 'salut',
'menyaluti': 'salut',
'penyalutan': 'salut',
'kesamarataan': 'sama rata',
'penyamarataan': 'sama rata',
'menyamaratakan': 'sama rata',
'menyamaratakannya': 'sama rata',
'menyaman': 'saman',
'menyamanan': 'saman',
'kesamaptaan': 'samapta',
'menyambal': 'sambal',
'menyambalewa': 'sambalewa',
'menyambalewakan': 'sambalewa',
'bersambang': 'sambang',
'menyambang': 'sambang',
'menyambangi': 'sambang',
'menyambanginya': 'sambang',
'menyambangiku': 'sambang',
'menyambangimu': 'sambang',
'sambang darah': 'sambang',
'sambatan': 'sambat',
'sambatannya': 'sambat',
'sesambat': 'sambat',
'menyambat': 'sambat',
'bersambat': 'sambat',
'persambatan': 'sambat',
'penyambatan': 'sambat',
'menyambi': 'sambi',
'menyambinya': 'sambi',
'sambilan': 'sambil',
'sambilannya': 'sambil',
'tersambil': 'sambil',
'menyambilkan': 'sambil',
'menyambillalukan': 'sambil lalu',
'sambitan': 'sambit',
'menyambit': 'sambit',
'menyambitnya': 'sambit',
'penyambit': 'sambit',
'penyambitan': 'sambit',
'tersambit': 'sambit',
'menyambiti': 'sambit',
'menyambitkan': 'sambit',
'sambungan': 'sambung',
'sambungannya': 'sambung',
'bersambung': 'sambung',
'bersambungan': 'sambung',
'menyambung': 'sambung',
'menyambungnya': 'sambung',
'menyambungkan': 'sambung',
'menyambungkannya': 'sambung',
'menyambungan': 'sambung',
'penyambung': 'sambung',
'penyambungnya': 'sambung',
'penyambungan': 'sambung',
'penyambungannya': 'sambung',
'persambungan': 'sambung',
'mempersambungkan': 'sambung',
'sambung-bersambung': 'sambung',
'sambung-menyambung': 'sambung',
'bersambung tangan': 'sambung tangan',
'menyamir': 'samir',
'menyamirkan': 'samir',
'sampaian': 'sampai',
'sesampai': 'sampai',
'sesampainya': 'sampai',
'sesampaikan': 'sampai',
'penyampai': 'sampai',
'penyampaikan': 'sampai',
'penyampaian': 'sampai',
'tersampai': 'sampai',
'tersampainya': 'sampai',
'tersampaikan': 'sampai',
'tersampaikannya': 'sampai',
'menyampai': 'sampai',
'menyampainya': 'sampai',
'menyampaikan': 'sampai',
'menyampaikannya': 'sampai',
'menyampaian': 'sampai',
'kesampaian': 'sampai',
'kesampaiannya': 'sampai',
'penyampaiannya': 'sampai',
'menyampaikanlah': 'sampai',
'menyampaikankan': 'sampai',
'sampai-sampai': 'sampai',
'berkesampaian': 'sampai',
'menyampak': 'sampak',
'menyampakkan': 'sampak',
'menyampakan': 'sampak',
'bersampan': 'sampan',
'bersampan-sampan': 'sampan',
'kesamper': 'samper',
'menyamper': 'samper',
'menyamperi': 'samper',
'sampingan': 'samping',
'sampingannya': 'samping',
'sampinganmu': 'samping',
'tersamping': 'samping',
'tersampingkan': 'samping',
'menyamping': 'samping',
'menyampingnya': 'samping',
'menyampingkan': 'samping',
'menyampingi': 'samping',
'bersamping': 'samping',
'bersampingan': 'samping',
'penyampingan': 'samping',
'mengesampingkan': 'samping',
'mengesampingkannya': 'samping',
'samping-menyamping': 'samping',
'sampiran': 'sampir',
'tersampir': 'sampir',
'bersampiran': 'sampir',
'menyampirkan': 'sampir',
'menyampirkannya': 'sampir',
'bersamplok': 'samplok',
'menyampo': 'sampo',
'menyampoi': 'sampo',
'penyampoan': 'sampo',
'penyampul': 'sampul',
'penyampulan': 'sampul',
'menyampul': 'sampul',
'menyampulnya': 'sampul',
'bersampul': 'sampul',
'bersampulkan': 'sampul',
'menyampuli': 'sampul',
'persamuhan': 'samuh',
'bersanak': 'sanak',
'menyanak': 'sanak',
'bersanat': 'sanat',
'menyandakan': 'sandak',
'bersandal': 'sandal',
'menyandera': 'sandera',
'menyanderanya': 'sandera',
'menyanderakan': 'sandera',
'menyanderaku': 'sandera',
'penyandera': 'sandera',
'penyanderanya': 'sandera',
'penyanderaan': 'sandera',
'penyanderaannya': 'sandera',
'sandingan': 'sanding',
'bersanding': 'sanding',
'bersandingnya': 'sanding',
'bersandingkan': 'sanding',
'bersandingan': 'sanding',
'menyanding': 'sanding',
'menyandingkan': 'sanding',
'menyandingkannya': 'sanding',
'menyandingan': 'sanding',
'menyandingi': 'sanding',
'menyandinginya': 'sanding',
'mempersandingkan': 'sanding',
'sandungan': 'sandung',
'sandungannya': 'sandung',
'kesandung': 'sandung',
'menyandung': 'sandung',
'menyandungnya': 'sandung',
'menyandungkan': 'sandung',
'tersandung': 'sandung',
'tersandungnya': 'sandung',
'tersandunglah': 'sandung',
'tersanga-sanga': 'sanga',
'bersangai': 'sangai',
'tersangai': 'sangai',
'menyangai': 'sangai',
'kesangaran': 'sangar',
'kesangarannya': 'sangar',
'tersangat': 'sanggat',
'kesangatan': 'sangat',
'bersangatan': 'sangat',
'menyangatkan': 'sangat',
'mempersangat': 'sangat',
'sangat-sangat': 'sangat',
'sangat-sangatlah': 'sangat',
'mempersangatkan': 'sangat',
'sanggahan': 'sanggah',
'sanggahannya': 'sanggah',
'penyanggah': 'sanggah',
'penyanggahnya': 'sanggah',
'penyanggahan': 'sanggah',
'menyanggah': 'sanggah',
'menyanggahnya': 'sanggah',
'menyanggam': 'sanggam',
'bersanggama': 'sanggama',
'menyanggang': 'sanggang',
'menyanggep': 'sanggep',
'menyanggerah': 'sanggerah',
'bersanggit': 'sanggit',
'menyanggit': 'sanggit',
'menyanggrah': 'sanggrah',
'pesanggrahan': 'sanggrah',
'menyanggul': 'sanggul',
'menyanggulnya': 'sanggul',
'bersanggul': 'sanggul',
'menyanggulkan': 'sanggul',
'sesanggup': 'sanggup',
'sesanggupnya': 'sanggup',
'sesanggupan': 'sanggup',
'menyanggupi': 'sanggup',
'menyanggupinya': 'sanggup',
'kesanggupan': 'sanggup',
'kesanggupannya': 'sanggup',
'menyanggupkan': 'sanggup',
'sesangkak': 'sangkak',
'bersangkak': 'sangkak',
'menyangkak': 'sangkak',
'menyangkaki': 'sangkak',
'menyangkap': 'sangkap',
'sangkaran': 'sangkar',
'bersangkar': 'sangkar',
'menyangkarkan': 'sangkar',
'bersangkut paut': 'sangkut paut',
'menyangkutpautkan': 'sangkut paut',
'menyangling': 'sangling',
'menyanglingkan': 'sangling',
'menyangrai': 'sangrai',
'menyangrainya': 'sangrai',
'kesangsang': 'sangsang',
'menyangsang': 'sangsang',
'tersangsang': 'sangsang',
'bersanksi': 'sanksi',
'pesantai': 'santai',
'bersantai': 'santai',
'bersantainya': 'santai',
'bersantailah': 'santai',
'kesantaian': 'santai',
'bersantai-santai': 'santai',
'menyantak': 'santak',
'menyantakan': 'santak',
'menyantakkan': 'santak',
'bersantan': 'santan',
'bersantanlah': 'santan',
'pesantap': 'santap',
'santapan': 'santap',
'santapannya': 'santap',
'bersantap': 'santap',
'bersantapnya': 'santap',
'bersantaplah': 'santap',
'menyantap': 'santap',
'menyantapnya': 'santap',
'penyantapan': 'santap',
'persantapan': 'santap',
'menyantet': 'santet',
'menyantetnya': 'santet',
'santiran': 'santir',
'pesantrian': 'santri',
'santunan': 'santun',
'santunannya': 'santun',
'penyantun': 'santun',
'penyantunan': 'santun',
'menyantun': 'santun',
'menyantunkan': 'santun',
'menyantuni': 'santun',
'menyantuninya': 'santun',
'menyantung': 'santung',
'sapai-sapai': 'sapai',
'sapihan': 'sapih',
'menyapih': 'sapih',
'menyapihnya': 'sapih',
'sapuan': 'sapu',
'sapuannya': 'sapu',
'disapu': 'sapu',
'disapunya': 'sapu',
'disapukan': 'sapu',
'tersapu': 'sapu',
'tersapunya': 'sapu',
'menyapu': 'sapu',
'menyapunya': 'sapu',
'menyapulah': 'sapu',
'menyapukan': 'sapu',
'menyapukannya': 'sapu',
'penyapu': 'sapu',
'penyapunya': 'sapu',
'penyapuan': 'sapu',
'sapu-sapu': 'sapu',
'menyapu-nyapu': 'sapu',
'menyaput': 'saput',
'tersaput': 'saput',
'menyaputi': 'saput',
'bersarak': 'sarak',
'menyarak': 'sarak',
'sarapan': 'sarap',
'sarapannya': 'sarap',
'sarapanlah': 'sarap',
'sarapanku': 'sarap',
'menyarap': 'sarap',
'menyarapi': 'sarap',
'bersarasehan': 'sarasehan',
'menyarasehankan': 'sarasehan',
'menyarat': 'sarat',
'menyaratkan': 'sarat',
'menyarati': 'sarat',
'menyarat-nyarat': 'sarat',
'menyaraukan': 'sarau',
'menyaripatikan': 'sari pati',
'tersaripatikan': 'sari pati',
'kesarjanaan': 'sarjana',
'kesarjanaannya': 'sarjana',
'menyaru': 'saru',
'menyarukan': 'saruk',
'menyarukannya': 'saru',
'penyaruan': 'saru',
'penyaruannya': 'saru',
'menyaruk': 'saruk',
'tersaruk': 'saruk',
'tersaruk-saruk': 'saruk',
'menyarut': 'sarut',
'sasakan': 'sasak',
'sasakannya': 'sasak',
'menyasak': 'sasak',
'bersasak': 'sasak',
'menyasap': 'sasap',
'menyasau': 'sasau',
'kesastraan': 'sastra',
'kesastrawanan': 'sastrawan',
'menyatai': 'satai',
'menyataian': 'satai',
'persataian': 'satai',
'mempersatai': 'satai',
'menyatih': 'satih',
'menyatroni': 'satron',
'menyatumejakan': 'satu meja',
'bersatu padu': 'satu padu',
'penyatupaduan': 'satu padu',
'menyatupadukan': 'satu padu',
'mempersatupadukan': 'satu padu',
'bersauh': 'sauh',
'bersauhnya': 'sauh',
'saukan': 'sauk',
'saukani': 'sauk',
'menyauk': 'sauk',
'penyaukan': 'sauk',
'sauk-sauk': 'sauk',
'sauk-menyauk': 'sauk',
'tersaur': 'saur',
'bersaur': 'saur',
'menyaur': 'saur',
'menyauri': 'saur',
'pesawah': 'sawah',
'pesawahan': 'sawah',
'bersawah': 'sawah',
'penyawah': 'sawah',
'menyawah': 'sawah',
'persawahan': 'sawah',
'persawahannya': 'sawah',
'persawahanan': 'sawah',
'bersawala': 'sawala',
'sawangan': 'sawang',
'pesawangan': 'sawang',
'menyawar': 'sawar',
'menyawarkan': 'sawar',
'menyawer': 'sawer',
'sesawi': 'sawi',
'sawitan': 'sawit',
'bersayap': 'sayap',
'bersayapnya': 'sayap',
'menyayembarakan': 'sayembara',
'menyayung': 'sayung',
'sayup-sayup': 'sayup',
'sesayup-sayup': 'sayup',
'sayup-menyayup': 'sayup',
'sayuran': 'sayur',
'sayurannya': 'sayur',
'menyayur': 'sayur',
'menyayurnya': 'sayur',
'sayur-mayur': 'sayur',
'sayur-mayurnya': 'sayur',
'sayur-mayuran': 'sayur',
'sayur-sayuran': 'sayur',
'sayur-sayurannya': 'sayur',
'sayur-sayuranan': 'sayur',
'berseba': 'seba',
'menyeba': 'seba',
'menyebakan': 'seba',
'tersebab': 'sebab',
'bersebab': 'sebab',
'penyebab': 'sebab',
'penyebabnya': 'sebab',
'penyebabkan': 'sebab',
'penyebaban': 'sebab',
'menyebabkan': 'sebab',
'menyebabkannya': 'sebab',
'menyebabkankan': 'sebab',
'menyebabkankannya': 'sebab',
'menyebabkanku': 'sebab',
'menyebabkanmu': 'sebab',
'menyebal': 'sebal',
'menyebalkan': 'sebal',
'menyebalkannya': 'sebal',
'kesebalan': 'sebal',
'kesebalannya': 'sebal',
'menyebalkanmu': 'sebal',
'menyebaurkan': 'sebaur',
'penyeberang': 'seberang',
'penyeberangnya': 'seberang',
'penyeberangi': 'seberang',
'penyeberangan': 'seberang',
'terseberang': 'seberang',
'terseberangkan': 'seberang',
'menyeberang': 'seberang',
'menyeberangnya': 'seberang',
'menyeberanglah': 'seberang',
'menyeberangkan': 'seberang',
'menyeberangkannya': 'seberang',
'menyeberangi': 'seberang',
'menyeberangan': 'seberang',
'menyeberanginya': 'seberang',
'keseberangan': 'seberang',
'penyeberangannya': 'seberang',
'berseberangan': 'seberang',
'berseberangannya': 'seberang',
'seberang-menyeberang': 'seberang',
'menyebit': 'sebit',
'menyebitkan': 'sebit',
'menyebrot': 'sebrot',
'menyebu': 'sebu',
'menyebunya': 'sebu',
'menyebukan': 'sebuk',
'menyebuk': 'sebuk',
'penyebukan': 'sebuk',
'tersedak': 'sedak',
'tersedaknya': 'sedak',
'kesedakan': 'sedak',
'sedam-sedam': 'sedam',
'bersedan-sedan': 'sedan',
'tersedan-sedan': 'sedan',
'menyedang': 'sedang',
'sedangkan': 'sedang',
'sedangkankan': 'sedang',
'sedangkani': 'sedang',
'sedangkanan': 'sedang',
'menyedangkan': 'sedang',
'sedang-menyedang': 'sedang',
'menyedang-nyedang': 'sedang',
'menyedang-nyedangkan': 'sedang',
'bersedekah': 'sedekah',
'bersedekahlah': 'sedekah',
'menyedekahi': 'sedekah',
'menyedekahkan': 'sedekah',
'bersedekap': 'sedekap',
'kesederhanaan': 'sederhana',
'kesederhanaannya': 'sederhana',
'penyederhanaan': 'sederhana',
'penyederhanaannya': 'sederhana',
'menyederhanakan': 'sederhana',
'menyederhanakannya': 'sederhana',
'sedikitnya': 'sedikit',
'menyedikit': 'sedikit',
'tersedikit': 'sedikit',
'menyedikiti': 'sedikit',
'menyedikitkan': 'sedikit',
'sedikit-sedikit': 'sedikit',
'sedikit-sedikitlah': 'sedikit',
'mempersedikitkan': 'sedikit',
'sedikit-sedikitnya': 'sedikit',
'sedotan': 'sedot',
'sedotannya': 'sedot',
'sedotanlah': 'sedot',
'tersedot': 'sedot',
'tersedotnya': 'sedot',
'menyedot': 'sedot',
'menyedotnya': 'sedot',
'menyedotan': 'sedot',
'penyedot': 'sedot',
'penyedotnya': 'sedot',
'penyedotan': 'sedot',
'penyedotannya': 'sedot',
'bersedu': 'sedu',
'tersedu-sedu': 'sedu',
'bersedu-sedu': 'sedu',
'menyegak': 'segak',
'segalanya': 'segala',
'segala-galanya': 'segala',
'bersegeh': 'segeh',
'menyegehi': 'segeh',
'segelan': 'segel',
'segelannya': 'segel',
'bersegel': 'segel',
'menyegel': 'segel',
'menyegelnya': 'segel',
'menyegelan': 'segel',
'penyegel': 'segel',
'penyegelan': 'segel',
'penyegelannya': 'segel',
'sesegera': 'segera',
'sesegeranya': 'segera',
'bersegera': 'segera',
'bersegeralah': 'segera',
'persegeraan': 'segera',
'penyegeraan': 'segera',
'menyegerakan': 'segera',
'menyegerakannya': 'segera',
'mempersegera': 'segera',
'mepersegerakan': 'segera',
'bersegmen': 'segmen',
'bersegmenkan': 'segmen',
'menyegmentasikan': 'segmentasi',
'kesejahteraan': 'sejahtera',
'kesejahteraannya': 'sejahtera',
'kesejahteraanlah': 'sejahtera',
'kesejahteraanku': 'sejahtera',
'penyejahteraan': 'sejahtera',
'menyejahterakan': 'sejahtera',
'menyejahterakannya': 'sejahtera',
'bersejingkat': 'sejingkat',
'bersejuk': 'sejuk',
'menyejuk': 'sejuk',
'menyejukkan': 'sejuk',
'menyejukkannya': 'sejuk',
'menyejukan': 'sejuk',
'penyejuk': 'sejuk',
'penyejukan': 'sejuk',
'kesejukan': 'sejuk',
'kesejukannya': 'sejuk',
'bersejuk-sejuk': 'sejuk',
'tersekang': 'sekang',
'penyekang': 'sekang',
'menyekang': 'sekang',
'sekapan': 'sekap',
'sekapannya': 'sekap',
'penyekap': 'sekap',
'penyekapnya': 'sekap',
'penyekapkan': 'sekap',
'penyekapan': 'sekap',
'tersekap': 'sekap',
'menyekap': 'sekap',
'menyekapnya': 'sekap',
'menyekapan': 'sekap',
'penyekapannya': 'sekap',
'menyekar': 'sekar',
'sekatan': 'sekat',
'persekat': 'sekat',
'persekatan': 'sekat',
'bersekat': 'sekat',
'penyekat': 'sekat',
'penyekatnya': 'sekat',
'penyekatan': 'sekat',
'menyekat': 'sekat',
'menyekati': 'sekat',
'menyekatan': 'sekat',
'tersekat': 'sekat',
'bersekat-sekat': 'sekat',
'bersekresi': 'sekresi',
'menyekresi': 'sekresi',
'menyekresikan': 'sekresi',
'disekrup': 'sekrup',
'menyekrup': 'sekrup',
'bersekutu': 'sekutu',
'menyekutui': 'sekutu',
'persekutuan': 'sekutu',
'persekutuannya': 'sekutu',
'menyekutukan': 'sekutu',
'disel': 'sel',
'diselnya': 'sel',
'bersel': 'sel',
'berselan': 'sel',
'bersela': 'sela',
'berselai': 'sela',
'penyela': 'sela',
'penyelaan': 'sela',
'menyela': 'sela',
'menyelanya': 'sela',
'menyelakan': 'selak',
'menyelakannya': 'sela',
'penyelaannya': 'sela',
'sela-sela': 'sela',
'sela-selanya': 'sela',
'sela-menyela': 'sela',
'menyeladang': 'seladang',
'berselaju': 'selaju',
'keselak': 'selak',
'menyelak': 'selak',
'terselak': 'selak',
'menyelakkan': 'selak',
'menyelampai': 'selampai',
'menyelampaikan': 'selampai',
'menyelampitkan': 'selampit',
'berselang': 'selang',
'berselangan': 'selang',
'menyelang': 'selang',
'menyelangi': 'selang',
'menyelangkan': 'selang',
'memperselangi': 'selang',
'memperselangkan': 'selang',
'selang tenggang': 'selang',
'berselang-selang': 'selang',
'berselang-tenggang': 'selang',
'menyelang-nyelangkan': 'selang',
'berselang-seli': 'selang-seli',
'berselang-seling': 'selang-seling',
'menyelang-nyeling': 'selang-seling',
'menyelang-nyelingkan': 'selang-seling',
'selangkangan': 'selangkang',
'selangkangannya': 'selangkang',
'menyelangkupi': 'selangkup',
'terselap': 'selap',
'menyelap': 'selap',
'keselapan': 'selap',
'menyelapi': 'selap',
'selapanan': 'selapan',
'menyelara': 'selara',
'menyelarakan': 'selara',
'terselat': 'selat',
'terselatkan': 'selat',
'terselatan': 'selat',
'menyelat': 'selat',
'menyelatkan': 'selat',
'selawatan': 'selawat',
'berselawat': 'selawat',
'menyelawat': 'selawat',
'menyelawatkan': 'selawat',
'berselekeh': 'selekeh',
'menyelekehi': 'selekeh',
'berselekoh': 'selekoh',
'menyelekoh': 'selekoh',
'penyeleksi': 'seleksi',
'penyeleksinya': 'seleksi',
'penyeleksian': 'seleksi',
'menyeleksi': 'seleksi',
'menyeleksinya': 'seleksi',
'menyeleksii': 'seleksi',
'penyeleksiannya': 'seleksi',
'keselektifan': 'selektif',
'berseleleran': 'seleler',
'menyelembana': 'selembana',
'terselempang': 'selempang',
'berselempang': 'selempang',
'berselempangkan': 'selempang',
'menyelempangkan': 'selempang',
'menyelendang': 'selendang',
'berselendang': 'selendang',
'menyelendangi': 'selendang',
'memperselendang': 'selendang',
'menyelendangkan': 'selendang',
'memperselendangkan': 'selendang',
'menyelentik': 'selentik',
'selentingan': 'selenting',
'selentingannya': 'selenting',
'menyelenting': 'selenting',
'menyelentingkan': 'selenting',
'berselepat': 'selepat',
'berselesa': 'selesa',
'menyeletuk': 'seletuk',
'penyelia': 'selia',
'penyelianya': 'selia',
'penyeliaan': 'selia',
'menyelia': 'selia',
'berselibut': 'selibut',
'menyeligi': 'seligi',
'menyeligit': 'seligit',
'menyelimpang': 'selimpang',
'4selimpat': 'selimpat',
'menyelimpat': 'selimpat',
'selingan': 'seling',
'selingannya': 'seling',
'penyeling': 'seling',
'berseling': 'seling',
'berselingan': 'seling',
'berselingku': 'seling',
'menyeling': 'seling',
'menyelingkan': 'seling',
'menyelingi': 'seling',
'menyelinginya': 'seling',
'menyelingar': 'selingar',
'menyelingkit': 'selingkit',
'berselingkit': 'selingkit',
'berselingkuh': 'selingkuh',
'berselingkuhnya': 'selingkuh',
'perselingkuhan': 'selingkuh',
'perselingkuhannya': 'selingkuh',
'menyelingkuhkan': 'selingkuh',
'menyelingkup': 'selingkup',
'menyelingkupi': 'selingkup',
'menyelir': 'selir',
'memperselir': 'selir',
'selir-menyelir': 'selir',
'memperselirkan': 'selir',
'berselirak': 'selirak',
'menyelisipkan': 'selisip',
'menyelisir': 'selisir',
'seliweran': 'seliwer',
'berseliweran': 'seliwer',
'berseloka': 'seloka',
'menyelomoti': 'selomot',
'menyelongkan': 'selong',
'menyelongkar': 'selongkar',
'menyelongsongi': 'selongsong',
'selonjoran': 'selonjor',
'berselonjor': 'selonjor',
'berselonjoran': 'selonjor',
'menyelonong': 'selonong',
'menyelot': 'selot',
'seloyongan': 'seloyong',
'berseloyong': 'seloyong',
'seloyong-seloyong': 'seloyong',
'berseluar': 'seluar',
'menyeluduk': 'seluduk',
'berseluk-beluk': 'seluk-beluk',
'menyelukat': 'selukat',
'berselulup': 'selulup',
'terselulur': 'selulur',
'peseluncur': 'seluncur',
'selundupan': 'selundup',
'selundupannya': 'selundup',
'penyelundup': 'selundup',
'penyelundupnya': 'selundup',
'penyelundupkan': 'selundup',
'penyelundupan': 'selundup',
'menyelundup': 'selundup',
'menyelundupnya': 'selundup',
'menyelundupkan': 'selundup',
'menyelundupkannya': 'selundup',
'menyelundupan': 'selundup',
'menyelundupi': 'selundup',
'penyelundupannya': 'selundup',
'menyelungkup': 'selungkup',
'menyelungkupi': 'selungkup',
'menyeluruh': 'seluruh',
'menyeluruhnya': 'seluruh',
'menyeluruhi': 'seluruh',
'keseluruhan': 'seluruh',
'keseluruhannya': 'seluruh',
'keseluruhanlah': 'seluruh',
'keseluruhanan': 'seluruh',
'menyelusuh': 'selusuh',
'menyelusup': 'selusup',
'menyelusupkan': 'selusup',
'terselusur': 'selusur',
'menyelusur': 'selusur',
'menyelusuri': 'selusur',
'penyelusuran': 'selusur',
'menyelusurkan': 'selusur',
'sema-sema': 'sema',
'bersemak': 'semak',
'menyemak': 'semak',
'menyemakan': 'semak',
'semak-semak': 'semak',
'semak-semaknya': 'semak',
'menyemakkan': 'semak',
'kesemanan': 'seman',
'bersemangat': 'semangat',
'bersemangatnya': 'semangat',
'bersemangatlah': 'semangat',
'bersemangatkan': 'semangat',
'menyemangati': 'semangat',
'menyemangatinya': 'semangat',
'menyemangatiku': 'semangat',
'penyemangatan': 'semangat',
'menyemangatkan': 'semangat',
'menyemangatkannya': 'semangat',
'kesemaran': 'semara',
'bersemayam': 'semayam',
'bersemayamnya': 'semayam',
'persemayaman': 'semayam',
'persemayamannya': 'semayam',
'menyemayamkan': 'semayam',
'menyemayamkannya': 'semayam',
'menyembai': 'sembai',
'tersembam': 'sembam',
'menyembam': 'sembam',
'menyembamkan': 'sembam',
'sembarangan': 'sembarang',
'sembarangannya': 'sembarang',
'sembaranganlah': 'sembarang',
'menyembarangi': 'sembarang',
'menyembat': 'sembat',
'menyembatkan': 'sembat',
'bersembayan': 'sembayan',
'kesembilan': 'sembilan',
'kesembilannya': 'sembilan',
'bersembilan': 'sembilan',
'sembiluan': 'sembilu',
'menyembilu': 'sembilu',
'sembiran': 'sembir',
'menyembir': 'sembir',
'bersemboyan': 'semboyan',
'menyemboyankan': 'semboyan',
'kesembronoan': 'sembrono',
'kesembronoannya': 'sembrono',
'menyembronokan': 'sembrono',
'menyembul': 'sembul',
'menyembulnya': 'sembul',
'menyembullah': 'sembul',
'menyembulkan': 'sembul',
'tersembul': 'sembul',
'tersembulnya': 'sembul',
'bersemburit': 'semburit',
'bersememeh': 'sememeh',
'semenan': 'semen',
'menyemen': 'semen',
'menyemennya': 'semen',
'bersemen': 'semen',
'penyemenan': 'semen',
'semena-mena': 'semena',
'semena-menanya': 'semena',
'kesemena-menaan': 'semena',
'bersemenda': 'semenda',
'semenda-menyemenda': 'semenda',
'semenggah-menggah': 'semenggah',
'kesementaraan': 'sementara',
'kesemestaan': 'semesta',
'semesteran': 'semester',
'semesterannya': 'semester',
'bersemi': 'semi',
'berseminya': 'semi',
'bersemilah': 'semi',
'menyemir': 'semir',
'menyemirnya': 'semir',
'menyemirkan': 'semir',
'bersemir': 'semir',
'bersempadan': 'sempadan',
'menyempadani': 'sempadan',
'sempalan': 'sempal',
'sempalannya': 'sempal',
'menyempal': 'sempal',
'tersempal': 'sempal',
'penyempal': 'sempal',
'penyempalan': 'sempal',
'menyempali': 'sempal',
'tersempalai': 'sempalai',
'menyempang': 'sempang',
'bersempang': 'sempang',
'bersempena': 'sempena',
'menyempenakan': 'sempena',
'tersempil': 'sempil',
'menyempil': 'sempil',
'menyempilkan': 'sempil',
'sempoyongan': 'sempoyong',
'sempritan': 'semprit',
'menyemprit': 'semprit',
'penyemprit': 'semprit',
'penyempritan': 'semprit',
'bersemprong': 'semprong',
'tersempul': 'sempul',
'bersempuras': 'sempuras',
'kesemrawutan': 'semrawut',
'kesemrawutannya': 'semrawut',
'tersemu': 'semu',
'menyemu': 'semu',
'penyemu': 'semu',
'menyemui': 'semu',
'semu-semu': 'semu',
'penyemuan': 'semu',
'menyemukan': 'semu',
'semuanya': 'semua',
'semuanyanya': 'semua',
'semuanyalah': 'semua',
'semuanyai': 'semua',
'semua-muanya': 'semua',
'menyemur': 'semur',
'menyemurkan': 'semur',
'menyemut': 'semut',
'menyemutnya': 'semut',
'menyemuti': 'semut',
'kesemutan': 'semut',
'kesemutannya': 'semut',
'semut-semutan': 'semut',
'senan': 'sen',
'sen-senan': 'sen',
'tersenak': 'senak',
'menyenak': 'senak',
'menyenakan': 'senak',
'kesenakan': 'senak',
'menyenakkan': 'senak',
'kesenak-senakan': 'senak',
'menyenak-nyenak': 'senak',
'pesenam': 'senam',
'bersenam': 'senam',
'bersenapan': 'senapan',
'tersendam': 'sendam',
'bersendar': 'sendar',
'tersendat': 'sendat',
'tersendatnya': 'sendat',
'tersendatan': 'sendat',
'menyendat': 'sendat',
'menyendatkan': 'sendat',
'penyendatan': 'sendat',
'tersendat-sendat': 'sendat',
'tersendat-sendatnya': 'sendat',
'bersendel': 'sendel',
'dengan -': 'sendiri',
'sendirian': 'sendiri',
'sendiriannya': 'sendiri',
'sendirianlah': 'sendiri',
'menyendiri': 'sendiri',
'menyendirinya': 'sendiri',
'sendirinya': 'sendiri',
'bersendiri': 'sendiri',
'penyendiri': 'sendiri',
'tersendiri': 'sendiri',
'tersendirinya': 'sendiri',
'tersendirikan': 'sendiri',
'kesendirian': 'sendiri',
'kesendiriannya': 'sendiri',
'kesendirianmu': 'sendiri',
'penyendirian': 'sendiri',
'menyendirikan': 'sendiri',
'sendiri-sendiri': 'sendiri',
'tersendok': 'sendok',
'menyendok': 'sendok',
'menyendoknya': 'sendok',
'menyendokkan': 'sendok',
'menyendoki': 'sendok',
'tersendorong': 'sendorong',
'bersendorongan': 'sendorong',
'bersendu': 'sendu',
'kesenduan': 'sendu',
'menyengaja': 'sengaja',
'menyengajakan': 'sengaja',
'bersengaja': 'sengaja',
'kesengajaan': 'sengaja',
'kesengajaannya': 'sengaja',
'menyengal': 'sengal',
'sengal-sengal': 'sengal',
'tersengal-sengal': 'sengal',
'menyengam': 'sengam',
'menyengar': 'sengar',
'menyengarkan': 'sengar',
'sengatan': 'sengat',
'sengatannya': 'sengat',
'penyengat': 'sengat',
'menyengat': 'sengat',
'menyengatnya': 'sengat',
'menyengatkan': 'sengat',
'menyengatku': 'sengat',
'tersengat': 'sengat',
'tersengatnya': 'sengat',
'bersengat': 'sengat',
'penyengatan': 'sengat',
'senggakan': 'senggak',
'menyenggak': 'senggak',
'menyenggaki': 'senggak',
'bersenggang': 'senggang',
'kesenggangan': 'senggang',
'menyenggangkan': 'senggang',
'senggang-tenggang': 'senggang',
'bersenggang-senggang': 'senggang',
'menyenggau': 'senggau',
'bersenggau-senggau': 'senggau',
'menyengget': 'sengget',
'kesenggol': 'senggol',
'senggolan': 'senggol',
'senggolannya': 'senggol',
'tersenggol': 'senggol',
'bersenggol': 'senggol',
'bersenggolan': 'senggol',
'menyenggol': 'senggol',
'menyenggolnya': 'senggol',
'menyenggolmu': 'senggol',
'bersenggolannya': 'senggol',
'penyenggolan': 'senggol',
'senggol-menyenggol': 'senggol',
'menyengguk': 'sengguk',
'tersengguk': 'sengguk',
'sesenggukan': 'sengguk',
'senggak-sengguk': 'sengguk',
'tersengguk-sengguk': 'sengguk',
'bersenggulung': 'senggulung',
'menyenggut': 'senggut',
'sengihan': 'sengih',
'tersengih': 'sengih',
'menyengih': 'sengih',
'menyenggihkan': 'sengih',
'menyengir': 'sengir',
'menyengit': 'sengit',
'menyengitkan': 'sengit',
'kesengitan': 'sengit',
'kesengitannya': 'sengit',
'menyengkak': 'sengkak',
'menyengkang': 'sengkang',
'penyengkang': 'sengkang',
'tersengkang': 'sengkang',
'bersengkarut': 'sengkarut',
'sengkedan': 'sengked',
'bersengkela': 'sengkela',
'menyengkela': 'sengkela',
'menyengkelangkan': 'sengkelang',
'menyengkeling': 'sengkeling',
'bersengkeling': 'sengkeling',
'menyengkelit': 'sengkelit',
'bersengkelit': 'sengkelit',
'sengkeran': 'sengker',
'menyengker': 'sengker',
'menyengkilit': 'sengkilit',
'tersengsam': 'sengsam',
'kesengsaman': 'sengsam',
'kesengsem': 'sengsem',
'kesengsemnya': 'sengsem',
'tersengsem': 'sengsem',
'menyenguk': 'senguk',
'tersengut-sengut': 'sengut',
'berseni': 'seni',
'menyeni': 'seni',
'kesenian': 'seni',
'keseniannya': 'seni',
'kesenianmu': 'seni',
'kesenimanan': 'seniman',
'kesenimanannya': 'seniman',
'kesenimananku': 'seniman',
'kesenioran': 'senior',
'keseniorannya': 'senior',
'kesenjaan': 'senja',
'kesenjangan': 'senjang',
'kesenjangannya': 'senjang',
'persenjangan': 'senjang',
'ketidaksenonohan': 'senonoh',
'bersenoyong': 'senoyong',
'sensoran': 'sensor',
'penyensor': 'sensor',
'penyensoran': 'sensor',
'menyensus': 'sensus',
'menyental': 'sental',
'menyentalkan': 'sental',
'menyentengi': 'senteng',
'kesentengan': 'senteng',
'menyentengkan': 'senteng',
'menyenteri': 'senter',
'menyenterinya': 'senter',
'sentilan': 'sentil',
'sentilannya': 'sentil',
'menyentil': 'sentil',
'menyentilnya': 'sentil',
'menyentilkan': 'sentil',
'tersentil': 'sentil',
'bersentosa': 'sentosa',
'kesentosaan': 'sentosa',
'menyentosakan': 'sentosa',
'kesentralan': 'sentral',
'penyentralan': 'sentral',
'menyentralkan': 'sentral',
'menyentralisasi': 'sentralisasi',
'menyentralisasikan': 'sentralisasi',
'tersentralisasi': 'sentralisasi',
'tersentralisasinya': 'sentralisasi',
'tersentralisasikan': 'sentralisasi',
'tersentuk': 'sentuk',
'senyuman': 'senyum',
'senyumannya': 'senyum',
'senyumanan': 'senyum',
'senyumanku': 'senyum',
'senyumanmu': 'senyum',
'tersenyum': 'senyum',
'tersenyumnya': 'senyum',
'tersenyumlah': 'senyum',
'menyenyumi': 'senyum',
'terseok-seok': 'seok',
'terseok-seoknya': 'seok',
'bersep': 'sep',
'menyepah': 'sepah',
'tersepah': 'sepah',
'bersepah': 'sepah',
'bersepah-sepah': 'sepah',
'pesepak bola': 'sepak bola',
'bersepak bola': 'sepak bola',
'persepakbolaan': 'sepak bola',
'persepakbolaannya': 'sepak bola',
'menyepan': 'sepan',
'bersepan': 'sepan',
'sepelan': 'sepel',
'menyepel': 'sepel',
'menyepelkannya': 'sepel',
'menyepelekan': 'sepele',
'menyepelekannya': 'sepele',
'menyeperah': 'seperah',
'sepertikan': 'seperti',
'sepertinya': 'seperti',
'sepertinyanya': 'seperti',
'menyepertikan': 'seperti',
'penyepit': 'sepit',
'penyepitan': 'sepit',
'tersepit': 'sepit',
'menyepit': 'sepit',
'sepoi-sepoi': 'sepoi',
'menyepuk': 'sepuk',
'tersepuk': 'sepuk',
'tersera-sera': 'sera',
'penyerahterimaan': 'serah terima',
'menyerahterimakan': 'serah terima',
'berserak': 'serak',
'berseraknya': 'serak',
'berserakkan': 'serak',
'berserakan': 'serak',
'menyerak': 'serak',
'menyerakkan': 'serak',
'menyerakan': 'serak',
'terserak': 'serak',
'terserakan': 'serak',
'berserakannya': 'serak',
'serak-serak': 'serak',
'berserak-serak': 'serak',
'terserak-serak': 'serak',
'menyerak-nyerakkan': 'serak',
'berserama': 'serama',
'serampangan': 'serampang',
'serampangannya': 'serampang',
'terserampang': 'serampang',
'menyerampang': 'serampang',
'keserampangan': 'serampang',
'serampang dua belas': 'serampang',
'terserampuk': 'serampuk',
'berseran': 'seran',
'menyerana': 'serana',
'menyerandang': 'serandang',
'terserandung': 'serandung',
'berseranggung': 'seranggung',
'menyeranggung': 'seranggung',
'menyerangsang': 'serangsang',
'penyeranian': 'serani',
'menyeranikan': 'serani',
'penyeranta': 'seranta',
'menyerantakan': 'seranta',
'diserap': 'serap',
'diserapnya': 'serap',
'serapan': 'serap',
'serapannya': 'serap',
'menyerap': 'serap',
'menyerapnya': 'serap',
'menyerapkan': 'serap',
'menyerapan': 'serap',
'terserap': 'serap',
'terserapnya': 'serap',
'penyerap': 'serap',
'penyerapan': 'serap',
'penyerapannya': 'serap',
'menyerapahi': 'serapah',
'menyeraya': 'seraya',
'menyerayakan': 'seraya',
'seraya-menyeraya': 'seraya',
'serba-serbi': 'serba',
'serba-serbinya': 'serba',
'keserbagunaan': 'serbaguna',
'menyerbak': 'serbak',
'menyerbakkan': 'serbak',
'beserban': 'serban',
'beserbankan': 'serban',
'menyerbeti': 'serbet',
'menyerbuk': 'serbuk',
'menyerbukkan': 'serbuk',
'menyerbuki': 'serbuk',
'menyerbukinya': 'serbuk',
'penyerbukan': 'serbuk',
'penyerbukannya': 'serbuk',
'beserdam': 'serdam',
'beserdawa': 'serdawa',
'beserdih': 'serdih',
'terserempak': 'serempak',
'keserempakan': 'serempak',
'keserempet': 'serempet',
'menyerempet': 'serempet',
'menyerempetnya': 'serempet',
'menyerempetkan': 'serempet',
'penyerempet': 'serempet',
'penyerempetan': 'serempet',
'terserempet': 'serempet',
'terserempetnya': 'serempet',
'menyerendeng': 'serendeng',
'menyerendengkan': 'serendeng',
'berserengam': 'serengam',
'menyerengeh': 'serengeh',
'berserenjang': 'serenjang',
'menyerepi': 'serep',
'menyerepkan': 'serep',
'menyergah': 'sergah',
'tesergam': 'sergam',
'sergapan': 'sergap',
'sergapannya': 'sergap',
'tesergap': 'sergap',
'menyergap': 'sergap',
'menyergapnya': 'sergap',
'menyergapi': 'sergap',
'menyergapan': 'sergap',
'menyergapku': 'sergap',
'penyergap': 'sergap',
'penyergapan': 'sergap',
'penyergapannya': 'sergap',
'berseri': 'seri',
'berserinya': 'seri',
'menyeri': 'seri',
'menyerikan': 'seri',
'perserian': 'seri',
'berseri-seri': 'seri',
'serak-serik': 'serik',
'berserikat': 'serikat',
'berserikatnya': 'serikat',
'berserikatkan': 'serikat',
'menyerikati': 'serikat',
'perserikatan': 'serikat',
'menyerikatkan': 'serikat',
'keserimpet': 'serimpet',
'menyerimpet': 'serimpet',
'menyerimpung': 'serimpung',
'penyerimpung': 'serimpung',
'terserimpung': 'serimpung',
'menyerindaikan': 'serindai',
'menyering': 'sering',
'menyeringkan': 'sering',
'sering-sering': 'sering',
'sering-seringnya': 'sering',
'sering-seringlah': 'sering',
'menyeringai': 'seringai',
'terseringing': 'seringing',
'menyeringing': 'seringing',
'menyerit': 'serit',
'menyeritkan': 'serit',
'menyerkah': 'serkah',
'menyerkai': 'serkai',
'penyerkup': 'serkup',
'menyerkup': 'serkup',
'menyerkupkan': 'serkup',
'teserling': 'serling',
'menyernak': 'sernak',
'terserobok': 'serobok',
'berserobok': 'serobok',
'menyerobot': 'serobot',
'menyerobotnya': 'serobot',
'penyerobot': 'serobot',
'penyerobotan': 'serobot',
'serobot-serobotan': 'serobot',
'serokan': 'serok',
'menyerok': 'serok',
'menyeroknya': 'serok',
'menyeroki': 'serok',
'terserok': 'serok',
'penyerok': 'serok',
'terserompok': 'serompok',
'terserondok': 'serondok',
'menyerondol': 'serondol',
'menyerondong': 'serondong',
'terserondong': 'serondong',
'keseronokan': 'seronok',
'menyeronokkan': 'seronok',
'menyeropot': 'seropot',
'menyerosoh': 'serosoh',
'terserot': 'serot',
'menyerot': 'serot',
'menyerotkan': 'serot',
'menyeroti': 'serot',
'seroyongan': 'seroyong',
'serpihan': 'serpih',
'serpihannya': 'serpih',
'menyerpih': 'serpih',
'penyerpihan': 'serpih',
'peserta': 'serta',
'pesertanya': 'serta',
'pesertai': 'serta',
'pesertaan': 'serta',
'beserta': 'serta',
'besertanya': 'serta',
'besertakan': 'serta',
'besertai': 'serta',
'besertaan': 'serta',
'besertamu': 'serta',
'penyerta': 'serta',
'penyertanya': 'serta',
'penyertakan': 'serta',
'penyertaan': 'serta',
'menyertai': 'serta',
'menyertainya': 'serta',
'menyertaiku': 'serta',
'menyertaimu': 'serta',
'kesertaan': 'serta',
'kesertaannya': 'serta',
'penyertaannya': 'serta',
'menyertakan': 'serta',
'menyertakannya': 'serta',
'serta-serta': 'serta',
'mempesertakan': 'serta',
'serta-menyertai': 'serta',
'kesertamertaan': 'serta-merta',
'penyertifikatan': 'sertifikat',
'menyertifikatkan': 'sertifikat',
'menyertu': 'sertu',
'seruan': 'seru',
'seruannya': 'seru',
'seruanku': 'seru',
'berseru': 'seru',
'penyeru': 'seru',
'penyerukan': 'seru',
'penyeruan': 'seru',
'menyeru': 'seru',
'menyerunya': 'seru',
'menyerukan': 'seru',
'menyerukannya': 'seru',
'menyeruan': 'seru',
'berseru-seru': 'seru',
'menyeru-nyerukan': 'seru',
'menyeruak': 'seruak',
'menyeruaknya': 'seruak',
'menyeruaklah': 'seruak',
'menyeruakkan': 'seruak',
'menyeruakan': 'seruak',
'penyerudi': 'serudi',
'berserudi': 'serudi',
'menyerudi': 'serudi',
'serudukan': 'seruduk',
'serudukannya': 'seruduk',
'keseruduk': 'seruduk',
'terseruduk': 'seruduk',
'penyeruduk': 'seruduk',
'penyerudukan': 'seruduk',
'menyeruduk': 'seruduk',
'menyeruduknya': 'seruduk',
'menyerudukkan': 'seruduk',
'menyerudukkannya': 'seruduk',
'menyeruit': 'seruit',
'bersuling': 'seruling',
'menyerum': 'serum',
'terserunda': 'serunda',
'berserunda': 'serunda',
'menyerunda': 'serunda',
'menyerundang': 'serundang',
'menyeruput': 'seruput',
'menyeruputnya': 'seruput',
'serutan': 'serut',
'serutannya': 'serut',
'menyerut': 'serut',
'menyerutnya': 'serut',
'penyerutan': 'serut',
'menyeruyuk': 'seruyuk',
'menyervis': 'servis',
'tersesak': 'sesak',
'menyesak': 'sesak',
'menyesakkan': 'sesak',
'menyesaki': 'sesak',
'menyesakan': 'sesak',
'kesesakan': 'sesak',
'bersesak-sesak': 'sesak',
'bersesak-sesakan': 'sesak',
'sesak-menyesak': 'sesak',
'sesapan': 'sesap',
'menyesap': 'sesap',
'menyesapkan': 'sesap',
'menyesapi': 'sesap',
'tersesap': 'sesap',
'penyesapan': 'sesap',
'sesaran': 'sesar',
'menyesar': 'sesar',
'bersesaran': 'sesar',
'penyesaran': 'sesar',
'menyesarkan': 'sesar',
'bersesat': 'sesat',
'tersesat': 'sesat',
'tersesatnya': 'sesat',
'tersesatkan': 'sesat',
'kesesatan': 'sesat',
'kesesatannya': 'sesat',
'penyesatan': 'sesat',
'menyesatkan': 'sesat',
'menyesatkannya': 'sesat',
'menyeser': 'seser',
'sesuai': 'suai',
'sesuainya': 'suai',
'sesuailah': 'suai',
'sesuaikan': 'suai',
'sesuaii': 'suai',
'sesuaian': 'suai',
'bersuai': 'suai',
'bersuaian': 'suai',
'bersesuai': 'suai',
'bersesuaian': 'suai',
'kesesuaian': 'suai',
'kesesuaiannya': 'suai',
'penyesuaian': 'suai',
'penyesuaiannya': 'suai',
'penyesuaianlah': 'suai',
'persesuaian': 'suai',
'persesuaiannya': 'suai',
'menyesuaikan': 'suai',
'menyesuaikannya': 'suai',
'menyesuaikanlah': 'suai',
'menyesuaikankan': 'suai',
'tersesuaikan': 'suai',
'berkesesuaian': 'suai',
'sesuatu': 'suatu',
'sesuatunya': 'suatu',
'sesuatulah': 'suatu',
'bersuatu': 'suatu',
'mempersuatukan': 'suatu',
'sesudah': 'sudah',
'sesudahnya': 'sudah',
'sesudahmu': 'sudah',
'bersudah': 'sudah',
'penyudah': 'sudah',
'penyudahan': 'sudah',
'menyudahi': 'sudah',
'menyudahinya': 'sudah',
'kesudahan': 'sudah',
'kesudahannya': 'sudah',
'mempersudah': 'sudah',
'menyudahkan': 'sudah',
'sesudah-sudah': 'sudah',
'bersudah-sudah': 'sudah',
'sesudah-sudahnya': 'sudah',
'berkesudahan': 'sudah',
'sungguhan': 'sungguh',
'sungguhannya': 'sungguh',
'kesungguhan': 'sungguhan',
'kesungguhannya': 'sungguhan',
'menyungguhi': 'sungguh',
'sesungguhnya': 'sungguhan',
'sesungguhnyalah': 'sungguhan',
'penyungguhan': 'sungguhan',
'menyungguhkan': 'sungguhan',
'berkesungguhan': 'sungguh',
'mempersungguhi': 'sungguh',
'sungguh-sungguh': 'sungguhan',
'sungguh-sungguhnya': 'sungguhan',
'bersungguh-sungguh': 'sungguhan',
'bersungguh-sungguhlah': 'sungguhan',
'menyungguh-nyungguhi': 'sungguh',
'pengeset': 'set',
'pengesetan': 'set',
'tersetai-setai': 'setai',
'bersetai-setai': 'setai',
'setakat': 'takat',
'menyetan': 'setan',
'persetan': 'setan',
'kesetanan': 'setan',
'kesetanannya': 'setan',
'mempersetan': 'setan',
'mempersetankan': 'setan',
'setara': 'tara',
'setaranya': 'tara',
'setaralah': 'tara',
'setarakan': 'tara',
'setaraan': 'tara',
'tertara': 'tara',
'bertara': 'tara',
'menarakan': 'tara',
'penyetara': 'tara',
'penyetarakan': 'tara',
'penyetaraan': 'tara',
'menyetarakan': 'tara',
'menyetarakannya': 'tara',
'setekan': 'setek',
'setelan': 'setel',
'setelannya': 'setel',
'menyetel': 'setel',
'menyetelnya': 'setel',
'menyetelkan': 'setel',
'penyetelan': 'setel',
'penyetelannya': 'setel',
'bersetelan': 'setel',
'menyetel-nyetel': 'setel',
'penelah': 'telah',
'penelahan': 'telah',
'menelah': 'telah',
'menelahan': 'telah',
'setelah': 'telah',
'setelahnya': 'telah',
'setelahkan': 'telah',
'setelahi': 'telah',
'menyetelengkan': 'seteleng',
'seteman': 'setem',
'menyetem': 'setem',
'penyeteman': 'setem',
'setengah': 'tengah',
'setengahnya': 'tengah',
'setengahlah': 'tengah',
'setengahnyalah': 'tengah',
'menengah': 'tengah',
'menengahnya': 'tengah',
'menengahkan': 'tengah',
'menengahi': 'tengah',
'tengahan': 'tengah',
'tengahannya': 'tengah',
'penengah': 'tengah',
'penengahnya': 'tengah',
'penengahan': 'tengah',
'menengahinya': 'tengah',
'pertengahan': 'tengah',
'pertengahannya': 'tengah',
'mengetengahi': 'tengah',
'mengetengahkan': 'tengah',
'setengah-setengah': 'tengah',
'kesetiakawanan': 'setia kawan',
'kesetiakawanannya': 'setia kawan',
'kesetiakawananan': 'setia kawan',
'bersetia': 'setia',
'kesetiaan': 'setia',
'kesetiaannya': 'setia',
'kesetiaanku': 'setia',
'setiba': 'tiba',
'setibanya': 'tiba',
'setikan': 'setik',
'setikannya': 'setik',
'menyetik': 'setik',
'timpalan': 'timpal',
'timpalannya': 'timpal',
'setimpal': 'timpal',
'menimpali': 'timpal',
'menimpalinya': 'timpal',
'menyetip': 'setip',
'setopan': 'setop',
'penyetop': 'setop',
'penyetopan': 'setop',
'menyetop': 'setop',
'menyetopnya': 'setop',
'menyetopkan': 'setop',
'menyetopmu': 'setop',
'setoran': 'setor',
'setorannya': 'setor',
'setoranlah': 'setor',
'menyetor': 'setor',
'menyetornya': 'setor',
'menyetorkan': 'setor',
'menyetorkannya': 'setor',
'penyetor': 'setor',
'penyetornya': 'setor',
'penyetorkan': 'setor',
'penyetoran': 'setor',
'penyetorannya': 'setor',
'setrapan': 'setrap',
'menyetrap': 'strap',
'penyetrapan': 'setrap',
'setrikaan': 'setrika',
'bersetrika': 'setrika',
'menyetrika': 'setrika',
'menyetrikanya': 'setrika',
'menyetrikakan': 'setrika',
'penyetrika': 'setrika',
'penyetrikaan': 'setrika',
'bersetrip': 'setrip',
'menyetrip': 'setrip',
'penyetripan': 'setrip',
'kesetrum': 'setrum',
'tersetrum': 'setrum',
'tersetrumnya': 'setrum',
'menyetrum': 'setrum',
'menyetrumnya': 'setrum',
'menyetrumkan': 'setrum',
'menyetrumku': 'setrum',
'penyetruman': 'setrum',
'menyetui': 'setu',
'menyetum': 'setum',
'penyetuman': 'setum',
'menyetup': 'setup',
'bersewaka': 'sewaka',
'menyewat': 'sewat',
'sewot-sewotan': 'sewot',
'sia-sia': 'sia',
'sia-sianya': 'sia',
'sia-sialah': 'sia',
'sia-siakan': 'sia',
'tersia-sia': 'sia-sia',
'tersia-siakan': 'sia-sia',
'bersia-sia': 'sia-sia',
'kesia-siaan': 'sia-sia',
'menyia-nyiakan': 'sia-sia',
'menyia-nyiakannya': 'sia-sia',
'bersiaga': 'siaga',
'bersiaganya': 'siaga',
'bersiagalah': 'siaga',
'kesiagaan': 'siaga',
'kesiagaannya': 'siaga',
'menyiagakan': 'siaga',
'tersiah': 'siah',
'bersiah': 'siah',
'menyiah': 'siah',
'menyiahkan': 'siah',
'sesiak': 'siak',
'bersiakon': 'siakon',
'sialan': 'sial',
'kesialan': 'sial',
'kesialannya': 'sial',
'menyialkan': 'sial',
'bersialang': 'sialang',
'bersiap sedia': 'siap sedia',
'kesiapsiagaan': 'siap siaga',
'kesiapsiagaannya': 'siap siaga',
'siapa-siapa': 'siapa',
'siapa-siapanya': 'siapa',
'menyiat': 'siat',
'menyiatkan': 'siat',
'menyibak': 'sibak',
'menyibaknya': 'sibak',
'menyibakkan': 'sibak',
'menyibakan': 'sibak',
'bersibak': 'sibak',
'menyibak-nyibak': 'sibak',
'sesibar': 'sibar',
'bersibar': 'sibar',
'bersibaran': 'sibar',
'sibar-sibar': 'sibar',
'sibiran': 'sibir',
'sesibir': 'sibir',
'menyibuk': 'sibuk',
'menyibukkan': 'sibuk',
'menyibukkannya': 'sibuk',
'menyibukan': 'sibuk',
'bersibuk': 'sibuk',
'kesibukan': 'sibuk',
'kesibukannya': 'sibuk',
'kesibukanlah': 'sibuk',
'kesibukanku': 'sibuk',
'kesibukanmu': 'sibuk',
'menyibur': 'sibur',
'sibur-sibur': 'sibur',
'sida-sida': 'sida',
'menyidik': 'sidik',
'menyidiknya': 'sidik',
'menyidiki': 'sidik',
'menyidikan': 'sidik',
'penyidik': 'sidik',
'penyidiknya': 'sidik',
'penyidiklah': 'sidik',
'penyidikkan': 'sidik',
'penyidikkannya': 'sidik',
'penyidiki': 'sidik',
'penyidikan': 'sidik',
'penyidikannya': 'sidik',
'penyidikanlah': 'sidik',
'bersiduga': 'siduga',
'menyiduk': 'siduk',
'menyiduknya': 'siduk',
'disigai': 'sigai',
'menyigai': 'sigai',
'bersigai': 'sigai',
'bersigap': 'sigap',
'kesigapan': 'sigap',
'kesigapannya': 'sigap',
'menyigapkan': 'sigap',
'menyigar': 'sigar',
'penyigi': 'sigi',
'penyigian': 'sigi',
'menyigi': 'sigi',
'bersikap': 'sikap',
'bersikapnya': 'sikap',
'bersikaplah': 'sikap',
'menyikap': 'sikap',
'menyikapnya': 'sikap',
'menyikapi': 'sikap',
'menyikapinya': 'sikap',
'penyikat': 'sikat',
'penyikatan': 'sikat',
'menyikat': 'sikat',
'menyikatnya': 'sikat',
'menyikatkan': 'sikat',
'menyikati': 'sikat',
'bersikudidi': 'sikudidi',
'sikutan': 'sikut',
'sikutannya': 'sikut',
'tersikut': 'sikut',
'menyikut': 'sikut',
'menyikutnya': 'sikut',
'menyikuti': 'sikut',
'menyikutku': 'sikut',
'bersikutan': 'sikut',
'sikut-sikutan': 'sikut',
'bersikut-sikutan': 'sikut',
'silahkan': 'silah',
'silahkanlah': 'silah',
'silah-silah': 'silah',
'tersilam': 'silam',
'menyilam': 'silam',
'menyilamkan': 'silam',
'penyilap': 'silap',
'bersilap': 'silap',
'menyilap': 'silap',
'pesilat': 'silat',
'pesilatnya': 'silat',
'bersilat': 'silat',
'menyilat': 'silat',
'persilatan': 'silat',
'bersilaturahmi': 'silaturahmi',
'bersilengah': 'silengah',
'menyilet': 'silet',
'menyiletkannya': 'silet',
'menyileti': 'silet',
'penyiletan': 'silet',
'silihan': 'silih',
'bersilih': 'silih',
'menyilih': 'silih',
'penyilihan': 'silih',
'persilihan': 'silih',
'menyilik': 'silik',
'siliran': 'silir',
'silir-semilir': 'silir',
'bersilir-silir': 'silir',
'menyilukan': 'silu',
'menyimak': 'simak',
'menyimaknya': 'simak',
'bersimbang': 'simbang',
'menyimbang': 'simbang',
'menyimbangkan': 'simbang',
'menyimbangi': 'simbang',
'tersimbur': 'simbur',
'menyimbur': 'simbur',
'bersimbur': 'simbur',
'menyimburi': 'simbur',
'menyimburkan': 'simbur',
'bersimbur-simburan': 'simbur',
'bersimpai': 'simpai',
'tersimpai': 'simpai',
'menyimpai': 'simpai',
'menyimpaikan': 'simpai',
'simpangan': 'simpang',
'simpangannya': 'simpang',
'menyimpang': 'simpang',
'menyimpangnya': 'simpang',
'menyimpangkan': 'simpang',
'menyimpangi': 'simpang',
'menyimpangan': 'simpang',
'bersimpang': 'simpang',
'bersimpangan': 'simpang',
'persimpangan': 'simpang',
'persimpangannya': 'simpang',
'penyimpangan': 'simpang',
'penyimpangannya': 'simpang',
'bersimpang siur': 'simpang siur',
'kesimpangsiuran': 'simpang siur',
'kesimpangsiurannya': 'simpang siur',
'kesimpatan': 'simpat',
'bersimpati': 'simpati',
'kesimpatikan': 'simpatik',
'menyimpirkan': 'simpir',
'bersimpuh': 'simpuh',
'bersimpuhlah': 'simpuh',
'tersimpuh': 'simpuh',
'menyimpuk': 'simpuk',
'menyimpukan': 'simpuk',
'menyimulasi': 'simulasi',
'menyimulasikan': 'simulasi',
'menyimulasikannya': 'simulasi',
'bersinau-sinau': 'sinau',
'pesinden': 'sinden',
'menyinden': 'sinden',
'bersinergi': 'sinergi',
'bersinerginya': 'sinergi',
'bersinergilah': 'sinergi',
'bersinergii': 'sinergi',
'mengnyinergikan': 'sinergi',
'bersinetron': 'sinetron',
'penyinetronan': 'sinetron',
'menyinetronkan': 'sinetron',
'tersingahak': 'singahak',
'singgahan': 'singgah',
'bersinggah': 'singgah',
'bersinggahnya': 'singgah',
'menyinggahi': 'singgah',
'menyinggahinya': 'singgah',
'persinggahan': 'singgah',
'persinggahannya': 'singgah',
'mempersinggah': 'singgah',
'menyinggahkan': 'singgah',
'singgah-menyinggah': 'singgah',
'menyinggang': 'singgang',
'menyinggir': 'singgir',
'menyinggirkan': 'singgir',
'menyinggit': 'singgit',
'bersinggit': 'singgit',
'menyinggul': 'singgul',
'menyingit': 'singit',
'tersingit': 'singit',
'singkapan': 'singkap',
'tersingkap': 'singkap',
'tersingkapnya': 'singkap',
'tersingkaplah': 'singkap',
'tersingkapkan': 'singkap',
'menyingkap': 'singkap',
'menyingkapnya': 'singkap',
'menyingkapkan': 'singkap',
'menyingkapi': 'singkap',
'singkatan': 'singkat',
'singkatannya': 'singkat',
'penyingkat': 'singkat',
'penyingkatan': 'singkat',
'menyingkat': 'singkat',
'menyingkatnya': 'singkat',
'menyingkatkan': 'singkat',
'menyingkur': 'singkur',
'menyingsatkan': 'singsat',
'penyingset': 'singset',
'penyingsetan': 'singset',
'menyingsetkan': 'singset',
'sinian': 'sini',
'ke sini': 'sini',
'kesinian': 'sini',
'mengesinikan': 'sini',
'menyinkronkan': 'sinkron',
'menyinkronkannya': 'sinkron',
'kesinoniman': 'sinonim',
'penyinrili': 'sinrili',
'menyinter': 'sinter',
'penyinteran': 'sinter',
'menyintesis': 'sintesis',
'menyintesiskan': 'sintesis',
'kesintingan': 'sinting',
'kesintingannya': 'sinting',
'menyintuk': 'sintuk',
'bersintuk': 'sintuk',
'menyintukkan': 'sintuk',
'menyintung': 'sintung',
'mensinyalir': 'sinyalir',
'mensinyalirkan': 'sinyalir',
'sipatan': 'sipat',
'menyipat': 'sipat',
'menyipati': 'sipat',
'penyipatan': 'sipat',
'menyipatkan': 'sipat',
'menyipi': 'sipi',
'tersipi': 'sipi',
'menyipitkan': 'sipit',
'menyipitkannya': 'sipit',
'tersipu': 'sipu',
'kesipuan': 'sipu',
'tersipu-sipu': 'sipu',
'kesipu-sipuan': 'sipu',
'mengesir': 'sir',
'sir-siran': 'sir',
'tersirah': 'sirah',
'siraman': 'siram',
'siramannya': 'siram',
'menyiram': 'siram',
'menyiramnya': 'siram',
'menyiramkan': 'siram',
'menyiramkannya': 'siram',
'menyirami': 'siram',
'menyiraman': 'siram',
'bersiram': 'siram',
'penyiram': 'siram',
'penyiraman': 'siram',
'menyiraminya': 'siram',
'pesiraman': 'siram',
'penyiramannya': 'siram',
'persiraman': 'siram',
'tersirap': 'sirap',
'menyirapkan': 'sirap',
'siratan': 'sirat',
'menyirat': 'sirat',
'menyiratkan': 'sirat',
'menyirati': 'sirat',
'tersirat': 'sirat',
'tersiratnya': 'sirat',
'tersiratkan': 'sirat',
'sirat-sirat': 'sirat',
'kesirep': 'sirep',
'penyirep': 'sirep',
'menyirep': 'sirep',
'tersirep': 'sirep',
'menyirepi': 'sirep',
'penyirepan': 'sirep',
'penyirih': 'sirih',
'menyirih': 'sirih',
'menyirihi': 'sirih',
'penyirihan': 'sirih',
'menyirihkan': 'sirih',
'sirikan': 'sirik',
'menyirik': 'sirik',
'menyirikan': 'sirik',
'kesirikan': 'sirik',
'menyirnakan': 'sirna',
'bersiru': 'siru',
'tersisa': 'sisa',
'tersisanya': 'sisa',
'tersisalah': 'sisa',
'tersisakan': 'sisa',
'tersisai': 'sisa',
'bersisa': 'sisa',
'bersisakan': 'sisa',
'menyisai': 'sisa',
'menyisakan': 'sisa',
'menyisakannya': 'sisa',
'bersisalak': 'sisalak',
'bersisi': 'sisi',
'bersisikan': 'sisik',
'bersisian': 'sisi',
'ke sisi': 'sisi',
'menyisi': 'sisi',
'menyisikan': 'sisik',
'mengesisikan': 'sisi',
'menyisik': 'sisik',
'bersisik': 'sisik',
'menyisiki': 'sisik',
'menyisir': 'sisir',
'menyisirnya': 'sisir',
'menyisirlah': 'sisir',
'menyisiri': 'sisir',
'menyisiran': 'sisir',
'bersisir': 'sisir',
'kesisiran': 'sisir',
'bersistem': 'sistem',
'penyisteman': 'sistem',
'menyistemkan': 'sistem',
'bersisurut': 'sisurut',
'sitaan': 'sita',
'sitaannya': 'sita',
'menyita': 'sita',
'menyitanya': 'sita',
'menyitai': 'sita',
'penyita': 'sita',
'penyitaan': 'sita',
'penyitaannya': 'sita',
'menyitat': 'sitat',
'siteran': 'siter',
'menyitir': 'sitir',
'menyiuk': 'siuk',
'siulan': 'siul',
'siulannya': 'siul',
'bersiul': 'siul',
'bersiulan': 'siul',
'menyiulkan': 'siul',
'siungan': 'siung',
'bersiung': 'siung',
'berkesiuran': 'siur',
'berskala': 'skala',
'menskedulkan': 'skedul',
'menskemakan': 'skema',
'menskenariokan': 'skenario',
'mensketsa': 'sketsa',
'menskor': 'skor',
'penskoran': 'skor',
'penskorannya': 'skor',
'menskors': 'skors',
'menskorsnya': 'skors',
'penskorsan': 'skors',
'mensmokel': 'smokel',
'bersoal': 'soal',
'bersoalan': 'soal',
'menyoal': 'soal',
'menyoalkan': 'soal',
'menyoalkannya': 'soal',
'persoalan': 'soal',
'persoalannya': 'soal',
'persoalankan': 'soal',
'persoalanan': 'soal',
'persoalanmu': 'soal',
'mempersoalkan': 'soal',
'mempersoalkannya': 'soal',
'bersobat': 'sobat',
'menyobat': 'sobat',
'menyobati': 'sobat',
'persobatan': 'sobat',
'sesobek': 'sobek',
'sobekan': 'sobek',
'sobekannya': 'sobek',
'menyobek': 'sobek',
'menyobeknya': 'sobek',
'menyobeki': 'sobek',
'penyobekan': 'sobek',
'sobek-sobekan': 'sobek',
'menyobek-nyobek': 'sobek',
'menyobek-nyobeknya': 'sobek',
'tersobok': 'sobok',
'bersobok': 'sobok',
'soda kristal': 'soda kue',
'sodetan': 'sodet',
'sodetannya': 'sodet',
'menyodet': 'sodet',
'penyodetan': 'sodet',
'penyodok': 'sodok',
'penyodokan': 'sodok',
'menyodok': 'sodok',
'menyodoknya': 'sodok',
'menyodokkan': 'sodok',
'menyodokan': 'sodok',
'sodok-sodokan': 'sodok',
'menyodomi': 'sodomi',
'menyodominya': 'sodomi',
'penyodomi': 'sodomi',
'sodoran': 'sodor',
'sodorannya': 'sodor',
'menyodorkan': 'sodor',
'menyodorkannya': 'sodor',
'menyoga': 'soga',
'kesohor': 'sohor',
'kesohoran': 'sohor',
'tersohor': 'sohor',
'tersohornya': 'sohor',
'menyoja': 'soja',
'bersoja': 'soja',
'tersoja-soja': 'soja',
'bersokom': 'sokom',
'menyokom': 'sokom',
'menyokomkan': 'sokom',
'bersol': 'sol',
'mengesol': 'sol',
'mengesolkan': 'sol',
'menyolang': 'solang',
'menyolder': 'solder',
'menyolidkan': 'solid',
'pesolok': 'solok',
'penyolok': 'solok',
'mengesom': 'som',
'menyombol': 'sombol',
'tersomplok': 'somplok',
'bersomplokan': 'somplok',
'tersompok': 'sompok',
'menyondang': 'sondang',
'penyondong': 'sondong',
'menyondong': 'sondong',
'menyondongkan': 'sondong',
'tersongel': 'songel',
'menyongket': 'songket',
'menyongketkan': 'songket',
'bersongkok': 'songkok',
'menyongsong': 'songsong',
'menyongsongnya': 'songsong',
'menyongsongkan': 'songsong',
'menyongsongmu': 'songsong',
'bersongsong': 'songsong',
'songsong arus': 'songsong',
'sontekan': 'sontek',
'sontekannya': 'sontek',
'menyontek': 'sontek',
'menyonteknya': 'sontek',
'menyontekkan': 'sontek',
'menyontekan': 'sontek',
'menyontok': 'sontok',
'kesopansantunan': 'sopan santun',
'bersopan santun': 'sopan santun',
'menyopir': 'sopir',
'menyopiri': 'sopir',
'menyopirinya': 'sopir',
'bersorak-sorai': 'sorak-sorai',
'sorangan': 'sorang',
'kesorangan': 'sorang',
'kesorean': 'sore',
'tersoren': 'soren',
'sorogan': 'sorog',
'sorongan': 'sorong',
'menyorong': 'sorong',
'menyorongkan': 'sorong',
'menyorongkannya': 'sorong',
'tersorong': 'sorong',
'menyorong-nyorongkan': 'sorong',
'sortiran': 'sortir',
'penyortir': 'sortir',
'penyortiran': 'sortir',
'menyortir': 'sortir',
'menyortirnya': 'sortir',
'kesosialan': 'sosial',
'kesosialannya': 'sosial',
'bersosialisasi': 'sosialisasi',
'bersosialisasinya': 'sosialisasi',
'bersosialisasilah': 'sosialisasi',
'bersosialisasikan': 'sosialisasi',
'mensosialisasikan': 'sosialisasi',
'mensosialisasikannya': 'sosialisasi',
'sosohan': 'sosoh',
'penyosoh': 'sosoh',
'penyosohan': 'sosoh',
'bersosoh': 'sosoh',
'menyosoh': 'sosoh',
'penyosohannya': 'sosoh',
'menyosok': 'sosok',
'menyosokkan': 'sosok',
'bersosok': 'sosok',
'menyosor': 'sosor',
'menyosorkan': 'sosor',
'persotoan': 'soto',
'menyoyak': 'soyak',
'menyoyaknyoyak': 'soyak',
'berspekulasi': 'spekulasi',
'berspekulasilah': 'spekulasi',
'menspekulasikan': 'spekulasi',
'berspesialisasi': 'spesialisasi',
'menspion': 'spion',
'mensponsori': 'sponsor',
'mensponsorinya': 'sponsor',
'pensponsoran': 'sponsor',
'sponsor-sponsoran': 'sponsor',
'kespontanan': 'spontan',
'kesportifan': 'sportif',
'kestabilan': 'stabil',
'kestabilannya': 'stabil',
'penstabilan': 'stabil',
'penstabilannya': 'stabil',
'menstabilkan': 'stabil',
'menstabilkannya': 'stabil',
'penstandaran': 'standar',
'menstandarkan': 'standar',
'menstarter': 'starter',
'menstarternya': 'starter',
'menstarterkan': 'starter',
'berstatus': 'status',
'berstatusnya': 'status',
'berstatuskan': 'status',
'menstempel': 'stempel',
'berstempel': 'stempel',
'kesterilan': 'steril',
'kesterilannya': 'steril',
'pensterilan': 'steril',
'mensterilkan': 'steril',
'mensterilkannya': 'steril',
'menstilir': 'stilir',
'menstimulasi': 'stimulasi',
'menstimulasinya': 'stimulasi',
'menstimulasikan': 'stimulasi',
'menstimulasikannya': 'stimulasi',
'berstrata': 'strata',
'penstrataan': 'strata',
'menstratakan': 'strata',
'terstruktur': 'struktur',
'terstrukturnya': 'struktur',
'terstrukturi': 'struktur',
'berstruktur': 'struktur',
'berstrukturkan': 'struktur',
'penstrukturan': 'struktur',
'menstrukturkan': 'struktur',
'bersua': 'sua',
'bersuanya': 'sua',
'menyua': 'sua',
'menyuai': 'sua',
'tersua': 'sua',
'persuaan': 'sua',
'mempersuakan': 'sua',
'menyuak': 'suak',
'menyuaki': 'suak',
'menyuakakan': 'suaka',
'suam-suam': 'suam',
'bersuami': 'suami',
'bersuamikan': 'suami',
'mempersuami': 'suami',
'mempersuamikan': 'suami',
'suang-suang': 'suang',
'sesuang-suang': 'suang',
'menyuar': 'suar',
'menyuarkan': 'suar',
'menyuaran': 'suar',
'bersuar': 'suar',
'bersuaran': 'suar',
'tersuar': 'suar',
'bersuara': 'suara',
'bersuaranya': 'suara',
'bersuaralah': 'suara',
'penyuaraan': 'suara',
'menyuarakan': 'suara',
'menyuarakannya': 'suara',
'menyuarangkan': 'suarang',
'menyuasanai': 'suasana',
'menyubal': 'subal',
'menyubang': 'subang',
'menyubangkan': 'subang',
'bersubang': 'subang',
'menyublim': 'sublim',
'penyubliman': 'sublim',
'menyubordinasikan': 'subordinasi',
'menyubsider': 'subsider',
'bersubsidi': 'subsidi',
'bersubsidinya': 'subsidi',
'tersubstitusikan': 'substitusi',
'menyubversikan': 'subversi',
'penyuci hama': 'suci hama',
'menyucihamakan': 'suci hama',
'menyudet': 'sudet',
'menyudi': 'sudi',
'kesudian': 'sudi',
'menyudikan': 'sudi',
'bersudikan': 'sudi',
'mempersudikan': 'sudi',
'menyudip': 'sudip',
'menyudu': 'sudu',
'menyudukan': 'sudu',
'tersudu': 'sudu',
'sudu-sudu': 'sudu',
'sudung-sudung': 'sudung',
'menyudut': 'sudut',
'menyudutnya': 'sudut',
'menyudutkan': 'sudut',
'menyudutkannya': 'sudut',
'tersudut': 'sudut',
'tersudutnya': 'sudut',
'tersudutkan': 'sudut',
'menyudutkanku': 'sudut',
'kesufian': 'sufi',
'menyugar': 'sugar',
'pesugi': 'sugi',
'pesugian': 'sugi',
'menyugi': 'sugi',
'bersugi': 'sugi',
'sugi-sugi': 'sugi',
'suguhan': 'suguh',
'suguhannya': 'suguh',
'tersuguh': 'suguh',
'tersuguhlah': 'suguh',
'tersuguhkan': 'suguh',
'tersuguhkannya': 'suguh',
'tersuguhi': 'suguh',
'menyuguhi': 'suguh',
'menyuguhinya': 'suguh',
'menyuguhkan': 'suguh',
'menyuguhkannya': 'suguh',
'menyugun': 'sugun',
'menyugunkan': 'sugun',
'bersuh': 'suh',
'suitan': 'suit',
'bersuit': 'suit',
'sujian': 'suji',
'menyuji': 'suji',
'menyujikan': 'suji',
'bersuji': 'suji',
'bersujud': 'sujud',
'bersujudlah': 'sujud',
'tersujud': 'sujud',
'bersukacita': 'sukacita',
'bersukacitalah': 'sukacita',
'bersukaria': 'sukaria',
'kesuksesan': 'sukses',
'kesuksesannya': 'sukses',
'kesuksesanku': 'sukses',
'kesuksesanmu': 'sukses',
'menyukseskan': 'sukses',
'menyukseskannya': 'sukses',
'menyulang': 'sulang',
'menyulangi': 'sulang',
'menyulangkan': 'sulang',
'bersulang-sulang': 'sulang',
'sulang-menyulang': 'sulang',
'menyulih': 'sulih',
'menyulihi': 'sulih',
'kesultanan': 'sultan',
'kesultanannya': 'sultan',
'pesuluh': 'suluh',
'menyuluh': 'suluh',
'menyuluhi': 'suluh',
'bersuluh': 'suluh',
'penyuluh': 'suluh',
'penyuluhnya': 'suluh',
'penyuluhlah': 'suluh',
'penyuluhan': 'suluh',
'penyuluhannya': 'suluh',
'bersuluhkan': 'suluh',
'bersuluk': 'suluk',
'bersulur': 'sulur',
'menyulur': 'sulur',
'menyulurkan': 'sulur',
'sulur-suluran': 'sulur',
'menyulut': 'sulut',
'menyulutnya': 'sulut',
'menyulutkan': 'sulut',
'menyulutkannya': 'sulut',
'menyuluti': 'sulut',
'menyumba': 'sumba',
'menyumbakan': 'sumba',
'sumbangan': 'sumbang',
'sumbangannya': 'sumbang',
'sumbangankan': 'sumbang',
'menyumbang': 'sumbang',
'menyumbangnya': 'sumbang',
'menyumbanglah': 'sumbang',
'menyumbangkan': 'sumbang',
'menyumbangkannya': 'sumbang',
'menyumbangan': 'sumbang',
'penyumbang': 'sumbang',
'penyumbangnya': 'sumbang',
'penyumbangan': 'sumbang',
'sesumbar': 'sumbar',
'sesumbarnya': 'sumbar',
'sesumbar-mu': 'sumbar',
'bersumbar': 'sumbar',
'menyumbar': 'sumbar',
'sumbatan': 'sumbat',
'sumbatannya': 'sumbat',
'tersumbat': 'sumbat',
'tersumbatnya': 'sumbat',
'tersumbatkan': 'sumbat',
'penyumbat': 'sumbat',
'penyumbatnya': 'sumbat',
'penyumbatan': 'sumbat',
'menyumbat': 'sumbat',
'menyumbatnya': 'sumbat',
'menyumbatan': 'sumbat',
'penyumbatannya': 'sumbat',
'bersumber': 'sumber',
'bersumberkan': 'sumber',
'menyumbi': 'sumbi',
'bersumbu': 'sumbu',
'menyumbui': 'sumbu',
'persumbuan': 'sumbu',
'menyumbur': 'sumbur',
'menyumburkan': 'sumbur',
'menyumirkan': 'sumir',
'pesumo': 'sumo',
'tersumpal': 'sumpal',
'menyumpal': 'sumpal',
'menyumpalnya': 'sumpal',
'menyumpalkan': 'sumpal',
'menyumpalkannya': 'sumpal',
'kesumpekan': 'sumpek',
'sumpitan': 'sumpit',
'menyumpit': 'sumpit',
'tersumpit': 'sumpit',
'penyumpit': 'sumpit',
'penyumpitan': 'sumpit',
'sumpit-sumpit': 'sumpit',
'menyumsum': 'sumsum',
'sumuran': 'sumur',
'bersumur': 'sumur',
'mengesun': 'sun',
'disunahkan': 'sunah',
'menyunahkan': 'sunah',
'menyunam': 'sunam',
'menyunamkan': 'sunam',
'kesunanan': 'sunan',
'tersundak': 'sundak',
'menyundak': 'sundak',
'sundukan': 'sunduk',
'menyunduk': 'sunduk',
'menyunduki': 'sunduk',
'sundulan': 'sundul',
'sundulannya': 'sundul',
'sundulanku': 'sundul',
'sundulanmu': 'sundul',
'tersundul': 'sundul',
'penyundul': 'sundul',
'menyundul': 'sundul',
'menyundulnya': 'sundul',
'menyundulkan': 'sundul',
'menyundulku': 'sundul',
'penyundulan': 'sundul',
'menyundut': 'sundut',
'menyundutnya': 'sundut',
'menyundutkan': 'sundut',
'bersundut': 'sundut',
'penyundut': 'sundut',
'penyundutan': 'sundut',
'sundut-bersundut': 'sundut',
'menyungga': 'sungga',
'menyunggi': 'sunggi',
'menyungginya': 'sunggi',
'penyungging': 'sungging',
'menyungging': 'sungging',
'menyunggingkan': 'sungging',
'tersungging': 'sungging',
'penyunggingan': 'sungging',
'menyunggit': 'sunggit',
'sungguhpun': 'sungguhan',
'menyungkah': 'sungkah',
'menyungkahkan': 'sungkah',
'kesungkanan': 'sungkan',
'tersungkap': 'sungkap',
'bersungkawa': 'sungkawa',
'menyungkem': 'sungkem',
'menyungkit': 'sungkit',
'bersungkit': 'sungkit',
'tersungkuk': 'sungkuk',
'tersungkuk-sungkuk': 'sungkuk',
'menyungkum': 'sungkum',
'tersungkum': 'sungkum',
'menyungsang': 'sungsang',
'menyungsangkan': 'sungsang',
'tersunjam': 'sunjam',
'menyuntih': 'suntih',
'tersuntuk': 'suntuk',
'kesuntukan': 'suntuk',
'menyunu': 'sunu',
'kesunyataan': 'sunyata',
'penyuplai': 'suplai',
'penyuplainya': 'suplai',
'penyuplaian': 'suplai',
'menyuplai': 'suplai',
'menyuplainya': 'suplai',
'supletoar': 'suplir',
'persuratkabaran': 'surat kabar',
'suri teladan': 'suri',
'bersurih': 'surih',
'menyurih': 'surih',
'menyurihkan': 'surih',
'surukan': 'suruk',
'tersuruk': 'suruk',
'menyuruk': 'suruk',
'menyurukkan': 'suruk',
'menyurukan': 'suruk',
'menyuruki': 'suruk',
'bersurukan': 'suruk',
'suruk-surukan': 'suruk',
'tersuruk-suruk': 'suruk',
'menyuruk-nyuruk': 'suruk',
'bersuruk-surukan': 'suruk',
'kesurupan': 'surup',
'kesurupannya': 'surup',
'tersurut': 'surut',
'tersurutkan': 'surut',
'menyuruti': 'surut',
'menyurutkan': 'surut',
'menyurutkannya': 'surut',
'penyurvei': 'survei',
'penyurveinya': 'survei',
'penyurveian': 'survei',
'menyurvei': 'survei',
'menyurveinya': 'survei',
'bersusah hati': 'susah hati',
'bersusah': 'susah',
'menyusahi': 'susah',
'kesusahan': 'susah',
'kesusahannya': 'susah',
'menyusahkan': 'susah',
'menyusahkannya': 'susah',
'menyusahkanku': 'susah',
'mempersusah': 'susah',
'bersusah-susah': 'susah',
'kesusastraan': 'susastra',
'kesusastraannya': 'susastra',
'tersuspensi': 'suspensi',
'susteran': 'suster',
'susuan': 'susu',
'susuanan': 'susu',
'penyusu': 'susu',
'penyusukan': 'susu',
'penyusui': 'susu',
'penyusuan': 'susu',
'bersusu': 'susu',
'menyusu': 'susu',
'menyusunya': 'susu',
'menyusui': 'susu',
'menyusuan': 'susu',
'menyusuinya': 'susu',
'menyusuilah': 'susu',
'menyusuimu': 'susu',
'persusuan': 'susu',
'penyusuanan': 'susu',
'bersutan': 'sutan',
'bersutan-sutan': 'sutan',
'bersuten': 'suten',
'kesutradaraan': 'sutradara',
'menyutradarai': 'sutradara',
'menyutradarainya': 'sutradara',
'penyutradaraan': 'sutradara',
'penyutradaraannya': 'sutradara',
'menyuwir': 'suwir',
'suwir-suwir': 'suwir',
'keswasembadaan': 'swasembada',
'bersyahadat': 'syahadat',
'kesyahduan': 'syahdu',
'mensyaki': 'syak',
'mensyariatkan': 'syariat',
'mensyarikat': 'syarikat',
'bersyarikat': 'syarikat',
'mensyirikkan': 'syirik',
'bersyubhat': 'syubhat',
'syukuran': 'syukur',
'syukurannya': 'syukur',
'syukuranlah': 'syukur',
'bersyukur': 'syukur',
'bersyukurnya': 'syukur',
'bersyukurlah': 'syukur',
'bersyukurkan': 'syukur',
'mensyukuri': 'syukur',
'mensyukurinya': 'syukur',
'mensyurkan': 'syur',
'ketaatasasan': 'taat asas',
'menaati': 'taat',
'menaatinya': 'taat',
'ketaatan': 'taat',
'ketaatannya': 'taat',
'menabak': 'tabak',
'menabaknya': 'tabak',
'menabelkan': 'tabel',
'bertabiat': 'tabiat',
'pertabiban': 'tabib',
'menabik': 'tabik',
'menabikan': 'tabik',
'bersitabik': 'tabik',
'menabiri': 'tabir',
'bertabir': 'tabir',
'tabir-mabir': 'tabir',
'bertablig': 'tablig',
'menabligkan': 'tablig',
'menabok': 'tabok',
'tabrakan': 'tabrak',
'tabrakannya': 'tabrak',
'tabrakanlah': 'tabrak',
'menabrak': 'tabrak',
'menabraknya': 'tabrak',
'menabrakkan': 'tabrak',
'menabrakkannya': 'tabrak',
'menabraki': 'tabrak',
'menabrakan': 'tabrak',
'menabrakku': 'tabrak',
'menabrakmu': 'tabrak',
'penabrak': 'tabrak',
'penabraknya': 'tabrak',
'penabrakkan': 'tabrak',
'penabrakan': 'tabrak',
'tertabrak': 'tabrak',
'tertabraknya': 'tabrak',
'tertabrakan': 'tabrak',
'bertabrakan': 'tabrak',
'bertabrakannya': 'tabrak',
'tabrak-tubruk': 'tabrak',
'menabukan': 'tabu',
'menabuh': 'tabuh',
'menabuhnya': 'tabuh',
'menabuhkan': 'tabuh',
'tabuhan': 'tabuh',
'tabuhannya': 'tabuh',
'tetabuhan': 'tabuh',
'tabuh-tabuhan': 'tabuh',
'menabulasi': 'tabulasi',
'menabun': 'tabun',
'tabunan': 'tabun',
'tabun-menabun': 'tabun',
'menadaburkan': 'tadabur',
'bertadarus': 'tadarus',
'penadbir': 'tadbir',
'penadbiran': 'tadbir',
'menadbirkan': 'tadbir',
'tadinya': 'tadi',
'tertadung': 'tadung',
'menafahus': 'tafahus',
'tafsiran': 'tafsir',
'tafsirannya': 'tafsir',
'penafsiran': 'tafsir',
'penafsirannya': 'tafsir',
'menafsirkan': 'tafsir',
'menafsirkannya': 'tafsir',
'menagak': 'tagak',
'menagakkan': 'tagak',
'menagak-nagak': 'tagak',
'tertagak-tagak': 'tagak',
'menagan': 'tagan',
'menagani': 'tagan',
'bertagan': 'tagan',
'bertagar': 'tagar',
'bertahajud': 'tahajud',
'bertahak': 'tahak',
'bertahalul': 'tahalul',
'bertahana': 'tahana',
'setahap': 'tahap',
'tahapan': 'tahap',
'tahapannya': 'tahap',
'tahapani': 'tahap',
'tahapanan': 'tahap',
'bertahap': 'tahap',
'bertahapnya': 'tahap',
'bertahaplah': 'tahap',
'bertahapan': 'tahap',
'penahapan': 'tahap',
'penahapannya': 'tahap',
'menahapkan': 'tahap',
'bertahar': 'tahar',
'menaharkan': 'tahar',
'bertaharah': 'taharah',
'tahbisan': 'tahbis',
'penahbisan': 'tahbis',
'menahbiskan': 'tahbis',
'menahbiskannya': 'tahbis',
'ketahiran': 'tahir',
'penahiran': 'tahir',
'menahkikkan': 'tahkik',
'bertahkim': 'tahkim',
'tahlilan': 'tahlil',
'menahnik': 'tahnik',
'penaja': 'taja',
'penajanya': 'taja',
'penajaan': 'taja',
'menaja': 'taja',
'tajaan': 'taja',
'kepenajaan': 'taja',
'bertaji': 'taji',
'bertajinya': 'taji',
'menajin': 'tajin',
'menajinkan': 'tajin',
'menajuk': 'tajuk',
'menajukan': 'tajuk',
'bertajuk-tajuk': 'tajuk',
'penajur': 'tajur',
'ketakaburan': 'takabur',
'menakah': 'takah',
'takah-takahnya': 'takah',
'menakak': 'takak',
'bertakak': 'takak',
'menakar': 'takar',
'menakarnya': 'takar',
'setakar': 'takar',
'takaran': 'takar',
'takarannya': 'takar',
'takaranan': 'takar',
'penakar': 'takar',
'penakaran': 'takar',
'menakari': 'takar',
'penakarannya': 'takar',
'takbiran': 'takbir',
'takbirannya': 'takbir',
'menakbirkan': 'takbir',
'penakdisan': 'takdis',
'menakdiskan': 'takdis',
'menakhlikkan': 'takhlik',
'menakhsiskan': 'takhsis',
'bertakhta': 'takhta',
'bertakhtalah': 'takhta',
'bertakhtakan': 'takhta',
'menakhtakan': 'takhta',
'menaki': 'taki',
'bertaki': 'taki',
'menakjubi': 'takjub',
'ketakjuban': 'takjub',
'ketakjubannya': 'takjub',
'menakjubkan': 'takjub',
'menakjubkannya': 'takjub',
'bertaklid': 'taklid',
'menaklik': 'taklik',
'bertaklik': 'taklik',
'taklukan': 'takluk',
'taklukannya': 'takluk',
'penakluk': 'takluk',
'penakluknya': 'takluk',
'penaklukkan': 'takluk',
'penaklukkannya': 'takluk',
'penaklukan': 'takluk',
'penaklukannya': 'takluk',
'menaklukkan': 'takluk',
'menaklukkannya': 'takluk',
'menaklukkankan': 'takluk',
'menaklukkanku': 'takluk',
'menakma': 'takma',
'menakmakan': 'takma',
'takmurnian': 'takmurni',
'menakol': 'takol',
'ketakrifan': 'takrif',
'menakrifkan': 'takrif',
'ketaksaan': 'taksa',
'menaksikan': 'taksi',
'menakur': 'takur',
'menakurkan': 'takur',
'menakwilkan': 'takwil',
'bertakziah': 'takziah',
'menakzimkan': 'takzim',
'menakzirkan': 'takzir',
'bertalah-talah': 'talah',
'menalak': 'talak',
'menalaknya': 'talak',
'menalang': 'talang',
'menalangi': 'talang',
'penalang': 'talang',
'penalangan': 'talang',
'menalanginya': 'talang',
'bertalaran': 'talar',
'setali': 'tali',
'penali': 'tali',
'penalinya': 'tali',
'penalii': 'tali',
'penalian': 'tali',
'bertali': 'tali',
'bertalian': 'tali',
'tali-tali': 'tali',
'pertalian': 'tali',
'pertaliannya': 'tali',
'bertali-tali': 'tali',
'tali-bertali': 'tali',
'mempertalikan': 'tali',
'menalkinkan': 'talkin',
'bertalu-talu': 'talu',
'bertalun': 'talun',
'talun-temalun': 'talun',
'bertalun-talun': 'talun',
'bertamadun': 'tamadun',
'pertamanan': 'taman',
'pertamanannya': 'taman',
'pertamananan': 'taman',
'bertamasya': 'tamasya',
'tamatan': 'tamat',
'tamatannya': 'tamat',
'menamatkan': 'tamat',
'menamatkannya': 'tamat',
'menambal': 'tambal',
'menambalnya': 'tambal',
'menambalkan': 'tambal',
'menambali': 'tambal',
'menambalan': 'tambal',
'tambalan': 'tambal',
'tambalannya': 'tambal',
'penambalan': 'tambal',
'penambalannya': 'tambal',
'menambari': 'tambar',
'tambuhan': 'tambuh',
'bertambuh': 'tambuh',
'menambuhkan': 'tambuh',
'penambul': 'tambul',
'menambul': 'tambul',
'bertambul': 'tambul',
'menambun': 'tambun',
'tambunan': 'tambun',
'tambunanan': 'tambun',
'bertambun': 'tambun',
'bertambunnya': 'tambun',
'menambunkan': 'tambun',
'menambungi': 'tambung',
'menambus': 'tambus',
'tertambus': 'tambus',
'menamengi': 'tameng',
'menampak': 'tampak',
'menampakkan': 'tampak',
'menampakkannya': 'tampak',
'menampaki': 'tampak',
'menampakan': 'tampak',
'tampaknya': 'tampak',
'tertampak': 'tampak',
'penampakan': 'tampak',
'penampakannya': 'tampak',
'tampak-tampak': 'tampak',
'menampan': 'tampan',
'bertampan': 'tampan',
'mempertampan': 'tampan',
'penampang': 'tampang',
'penampangnya': 'tampang',
'penampangan': 'tampang',
'menampang': 'tampang',
'menampangkan': 'tampang',
'menampar': 'tampar',
'menamparnya': 'tampar',
'menamparkan': 'tampar',
'menampari': 'tampar',
'menamparku': 'tampar',
'menamparmu': 'tampar',
'tamparan': 'tampar',
'tamparannya': 'tampar',
'menamparinya': 'tampar',
'menampariku': 'tampar',
'bertampar': 'tampar',
'menampas': 'tampas',
'menampel': 'tampel',
'tampian': 'tampi',
'menampi': 'tampi',
'menampikan': 'tampik',
'penampi': 'tampi',
'penampilah': 'tampi',
'penampikan': 'tampik',
'penampian': 'tampi',
'tampikan': 'tampik',
'tampikannya': 'tampik',
'menampik': 'tampik',
'menampiknya': 'tampik',
'menampiklah': 'tampik',
'menampikkan': 'tampik',
'menampin': 'tampin',
'bertampin': 'tampin',
'bertampuk': 'tampuk',
'tamsilan': 'tamsil',
'bertamsil': 'tamsil',
'menamsilkan': 'tamsil',
'tertamsilkan': 'tamsil',
'menamu': 'tamu',
'menamukan': 'tamu',
'menamui': 'tamu',
'bertamu': 'tamu',
'bertamunya': 'tamu',
'ketamuan': 'tamu',
'menamyizkan': 'tamyiz',
'menanai': 'tanai',
'penanak': 'tanak',
'menanak': 'tanak',
'bertanak': 'tanak',
'sepenanak': 'tanak',
'sepertanak': 'tanak',
'mempertanak': 'tanak',
'mempertanakan': 'tanak',
'tanak-tanakan': 'tanak',
'sepenanak nasi': 'tanak',
'sepertanak nasi': 'tanak',
'menanang': 'tanang',
'menanangkan': 'tanang',
'menanangi': 'tanang',
'menancang': 'tancang',
'menancangkan': 'tancang',
'menancap': 'tancap',
'menancapnya': 'tancap',
'menancapkan': 'tancap',
'menancapkannya': 'tancap',
'tertancap': 'tancap',
'tertancapnya': 'tancap',
'penanda': 'tanda',
'penandanya': 'tanda',
'penandaan': 'tanda',
'bertanda': 'tanda',
'bertandakan': 'tandak',
'tertanda': 'tanda',
'tertandanya': 'tanda',
'tertandai': 'tanda',
'menandai': 'tanda',
'menandainya': 'tanda',
'menandaikan': 'tanda',
'pertanda': 'tanda',
'pertandanya': 'tanda',
'pertandaan': 'tanda',
'penandaannya': 'tanda',
'menandakan': 'tandak',
'menandakannya': 'tanda',
'bertanda-tandaan': 'tanda',
'penandak': 'tandak',
'menandak': 'tandak',
'menandakkan': 'tandak',
'bertandak': 'tandak',
'setandan': 'tandan',
'petandang': 'tandang',
'bertandang': 'tandang',
'bertandangnya': 'tandang',
'bertandanglah': 'tandang',
'bertandangan': 'tandang',
'menandangi': 'tandang',
'menanding': 'tanding',
'menandingnya': 'tanding',
'menandingkan': 'tanding',
'menandingkannya': 'tanding',
'menandingi': 'tanding',
'menandingan': 'tanding',
'tandingan': 'tanding',
'tandingannya': 'tanding',
'tandinganlah': 'tanding',
'menandinginya': 'tanding',
'bertanding': 'tanding',
'bertandingnya': 'tanding',
'bertandinglah': 'tanding',
'bertandingan': 'tanding',
'pertandingan': 'tanding',
'pertandingannya': 'tanding',
'pertandinganlah': 'tanding',
'pertandinganan': 'tanding',
'pertandinganku': 'tanding',
'mempertandingkan': 'tanding',
'mempertandingkannya': 'tanding',
'penandusan': 'tandus',
'menanduskan': 'tandus',
'penangas': 'tangas',
'menangas': 'tangas',
'bertangas': 'tangas',
'penangasan': 'tangas',
'setangga': 'tangga',
'bertangga': 'tangga',
'penanggah': 'tanggah',
'penanggahan': 'tanggah',
'menanggang': 'tanggang',
'bertanggang': 'tanggang',
'menanggar': 'tanggar',
'menanggarkan': 'tanggar',
'menanggul': 'tanggul',
'menangguli': 'tanggul',
'menanggulangi': 'tanggulang',
'menanggulanginya': 'tanggulang',
'penanggulangan': 'tanggulang',
'penanggulangannya': 'tanggulang',
'penanggulanganan': 'tanggulang',
'penanggung jawab': 'tanggung jawab',
'menanggungjawabi': 'tanggung jawab',
'bertanggung jawab': 'tanggung jawab',
'pertanggungjawaban': 'tanggung jawab',
'pertanggungjawabannya': 'tanggung jawab',
'pertanggungjawabanlah': 'tanggung jawab',
'pertanggungjawabankan': 'tanggung jawab',
'pertanggungjawabanan': 'tanggung jawab',
'mempertanggungjawabkan': 'tanggung jawab',
'mempertanggungjawabkannya': 'tanggung jawab',
'penanggung': 'tanggung',
'penanggungnya': 'tanggung',
'penanggungan': 'tanggung',
'menanggung': 'tanggung',
'menanggungnya': 'tanggung',
'menanggungkan': 'tanggung',
'menanggungi': 'tanggung',
'tanggungan': 'tanggung',
'tanggungannya': 'tanggung',
'tanggunganku': 'tanggung',
'tertanggung': 'tanggung',
'tertanggungkan': 'tanggung',
'pertanggungan': 'tanggung',
'pertanggungannya': 'tanggung',
'tanggung-tanggung': 'tanggung',
'mempertanggungkan': 'tanggung',
'tanggung-menanggung': 'tanggung',
'tangkahan': 'tangkah',
'menangkap': 'tangkap',
'menangkapnya': 'tangkap',
'menangkapkan': 'tangkap',
'menangkapi': 'tangkap',
'menangkapan': 'tangkap',
'menangkapku': 'tangkap',
'menangkapmu': 'tangkap',
'tangkapan': 'tangkap',
'tangkapannya': 'tangkap',
'tangkapanku': 'tangkap',
'penangkap': 'tangkap',
'penangkapnya': 'tangkap',
'penangkapkan': 'tangkap',
'penangkapan': 'tangkap',
'bertangkap': 'tangkap',
'tertangkap': 'tangkap',
'tertangkapnya': 'tangkap',
'tertangkaplah': 'tangkap',
'tertangkapkan': 'tangkap',
'sepenangkap': 'tangkap',
'sepenangkapan': 'tangkap',
'ketangkapan': 'tangkap',
'penangkapannya': 'tangkap',
'penangkapanan': 'tangkap',
'penangkapanku': 'tangkap',
'penangkar': 'tangkar',
'penangkaran': 'tangkar',
'penangkarannya': 'tangkar',
'menangkarkan': 'tangkar',
'menangkil': 'tangkil',
'bertangkil-tangkil': 'tangkil',
'menangkuk': 'tangkuk',
'menangkul': 'tangkul',
'setangkup': 'tangkup',
'menangkup': 'tangkup',
'menangkupnya': 'tangkup',
'menangkupkan': 'tangkup',
'bertangkup': 'tangkup',
'tertangkup': 'tangkup',
'menangkuptelentangkan': 'tangkup telentang',
'menangsel': 'tangsel',
'menanjul': 'tanjul',
'menanjuli': 'tanjul',
'tertanjul': 'tanjul',
'menanjung': 'tanjung',
'menanjur': 'tanjur',
'menanjur-nanjur': 'tanjur',
'menantang': 'tantang',
'menantangnya': 'tantang',
'menantangkan': 'tantang',
'menantangi': 'tantang',
'menantangku': 'tantang',
'menantangmu': 'tantang',
'penantang': 'tantang',
'penantangnya': 'tantang',
'penantangan': 'tantang',
'tantangan': 'tantang',
'tantangannya': 'tantang',
'tantangani': 'tantang',
'tantanganan': 'tantang',
'tantanganku': 'tantang',
'tantanganmu': 'tantang',
'tertantang': 'tantang',
'tertantanglah': 'tantang',
'bertanti': 'tanti',
'menanwinkan': 'tanwin',
'menapuk': 'tapuk',
'menapung': 'tapung',
'menapungnya': 'tapung',
'menapus': 'tapus',
'setaraf': 'taraf',
'bertaraf': 'taraf',
'menarafkan': 'taraf',
'menyetarafkan': 'taraf',
'bertarak': 'tarak',
'pertarakan': 'tarak',
'menarang': 'tarang',
'petarangan': 'tarang',
'bertarap': 'tarap',
'bertarawih': 'tarawih',
'menarbiahkan': 'tarbiah',
'penargetan': 'target',
'penargetannya': 'target',
'menargetkan': 'target',
'menargetkannya': 'target',
'penarifan': 'tarif',
'menarifkan': 'tarif',
'menarikhkan': 'tarikh',
'menaris': 'taris',
'bertajih': 'tarjih',
'bertaruk': 'taruk',
'menarupi': 'tarup',
'menasak': 'tasak',
'penasak': 'tasak',
'menasarufkan': 'tasaruf',
'bertasawuf': 'tasawuf',
'bertasbih': 'tasbih',
'bertasbihlah': 'tasbih',
'bertasbihkan': 'tasbih',
'menasdikkan': 'tasdik',
'penashih': 'tashih',
'menashih': 'tashih',
'menashihkan': 'tashih',
'menasrifkan': 'tasrif',
'tasyakuran': 'tasyakur',
'tasyakurannya': 'tasyakur',
'bertasyakur': 'tasyakur',
'bertasyhid': 'tasyhid',
'menasyhidkan': 'tasyhid',
'menasyrihkan': 'tasyrih',
'ketatabahasaan': 'tata bahasa',
'penatagunaan': 'tata guna',
'penata': 'tata',
'penatanya': 'tata',
'penataan': 'tata',
'menata': 'tata',
'menatanya': 'tata',
'menatakan': 'tata',
'tataan': 'tata',
'penataannya': 'tata',
'ketatalaksanaan': 'tata laksana',
'penatalaksanaan': 'tata laksana',
'penatalaksanaannya': 'tata laksana',
'ketatanegaraan': 'tata negara',
'ketatanegaraannya': 'tata negara',
'ketataniagaan': 'tata niaga',
'ketataprajaan': 'tata praja',
'ketatausahaan': 'tata usaha',
'bertatai-tatai': 'tatai',
'tatakan': 'tatak',
'tatakannya': 'tatak',
'menataki': 'tatak',
'tertatal': 'tatal',
'menatar': 'tatar',
'penatar': 'tatar',
'penataran': 'tatar',
'tataran': 'tatar',
'tatarannya': 'tatar',
'petatar': 'tatar',
'bertatar': 'tatar',
'penatarannya': 'tatar',
'menatih': 'tatih',
'tertatih-tatih': 'tatih',
'tertatih-tatihnya': 'tatih',
'bertatih-tatih': 'tatih',
'menating': 'tating',
'menato': 'tato',
'menatonya': 'tato',
'menauhidkan': 'tauhid',
'menaul': 'taul',
'bertauliah': 'tauliah',
'menauliahkan': 'tauliah',
'tauran': 'taur',
'menauri': 'taur',
'bertawajuh': 'tawajuh',
'menawaki': 'tawak',
'menawakkan': 'tawak',
'bertawakal': 'tawakal',
'tawanan': 'tawan',
'tawanannya': 'tawan',
'tawananan': 'tawan',
'penawan': 'tawan',
'penawanan': 'tawan',
'menawan': 'tawan',
'menawannya': 'tawan',
'menawanan': 'tawan',
'tertawan': 'tawan',
'bertawan-tawan': 'tawan',
'tawuran': 'tawur',
'tawurannya': 'tawur',
'tawuranlah': 'tawur',
'bertayamum': 'tayamum',
'tayuban': 'tayub',
'tayum-temayum': 'tayum',
'berteater': 'teater',
'meneaterkan': 'teater',
'tebakan': 'tebak',
'tebakannya': 'tebak',
'tebakanku': 'tebak',
'menebak': 'tebak',
'menebaknya': 'tebak',
'menebakkan': 'tebak',
'penebak': 'tebak',
'penebakan': 'tebak',
'meneban': 'teban',
'tebanan': 'teban',
'menebeng': 'tebeng',
'menebengnya': 'tebeng',
'bertebeng': 'tebeng',
'menebengkan': 'tebeng',
'menebing': 'tebing',
'menebok': 'tebok',
'tebu-tebu': 'tebu',
'menebu-nebu': 'tebu',
'bertebu-tebu': 'tebu',
'bertebu-tebukan': 'tebu',
'bertedengan': 'tedeng',
'tedong-tedong': 'tedong',
'meneduh': 'teduh',
'meneduhkan': 'teduh',
'meneduhi': 'teduh',
'peneduh': 'teduh',
'peneduhnya': 'teduh',
'peneduhan': 'teduh',
'berteduh': 'teduh',
'berteduhnya': 'teduh',
'berteduhlah': 'teduh',
'keteduhan': 'teduh',
'keteduhannya': 'teduh',
'perteduhan': 'teduh',
'perteduhannya': 'teduh',
'berteduhkan': 'teduh',
'ketegapan': 'tegap',
'menegapkan': 'tegap',
'menegun': 'tegun',
'bertegun': 'tegun',
'tertegun': 'tegun',
'tertegun-tegun': 'tegun',
'teh-tehan': 'teh',
'meneja': 'teja',
'berteka-teki': 'teka teki',
'peneka': 'tekaan',
'penekakan': 'tekaan',
'penekakannya': 'tekaan',
'menekak': 'tekak',
'menekakan': 'tekak',
'bertekak': 'tekak',
'menekang': 'tekang',
'menekat': 'tekat',
'menekati': 'tekat',
'tekatan': 'tekat',
'bertekat': 'tekat',
'bertekatkan': 'tekat',
'menekek': 'tekek',
'menekekan': 'tekek',
'menekel': 'tekel',
'menekelnya': 'tekel',
'menekelku': 'tekel',
'penekelan': 'tekel',
'meneken': 'teken',
'menekennya': 'teken',
'tekenan': 'teken',
'penekenan': 'teken',
'meneker': 'teker',
'tekeran': 'teker',
'ditekik': 'tekik',
'menekik': 'tekik',
'ketekoran': 'tekor',
'pertekstilan': 'tekstil',
'bertekstur': 'tekstur',
'menekuk': 'tekuk',
'menekuknya': 'tekuk',
'menekukkan': 'tekuk',
'menekukan': 'tekuk',
'tekukan': 'tekuk',
'bertekuk': 'tekuk',
'menekur': 'tekur',
'menekuri': 'tekur',
'bertekur': 'tekur',
'menekurkan': 'tekur',
'pertelaan': 'tela',
'menelaah': 'telaah',
'menelaahnya': 'telaah',
'penelaah': 'telaah',
'penelaahan': 'telaah',
'penelaahannya': 'telaah',
'bertelabat': 'telabat',
'meneladan': 'teladan',
'meneladankan': 'teladan',
'meneladani': 'teladan',
'meneladaninya': 'teladan',
'keteladanan': 'teladan',
'keteladanannya': 'teladan',
'keteladananan': 'teladan',
'keteladananmu': 'teladan',
'bertelang-telang': 'telang',
'menelangkai': 'telangkai',
'penelangkaian': 'telangkai',
'ketelanjuran': 'telanjur',
'penelantaran': 'telantar',
'penelantarannya': 'telantar',
'menelantarkan': 'telantar',
'menelantarkannya': 'telantar',
'menelantarkanku': 'telantar',
'menelap': 'telap',
'telapakan': 'telapak',
'petelasan': 'telas',
'bertelau-telau': 'telau',
'bertele-tele': 'tele',
'bertele-telenya': 'tele',
'bertele-telelah': 'tele',
'keteledoran': 'teledor',
'keteledorannya': 'teledor',
'meneledorkan': 'teledor',
'menelegram': 'telegram',
'bertelekan': 'telekan',
'pertelekomunikasian': 'telekomunikasi',
'berteleku': 'teleku',
'setelempap': 'telempap',
'menelempap': 'telempap',
'bertelempong': 'telempong',
'menelentang': 'telentang',
'menelentangkan': 'telentang',
'tertelentang': 'telentang',
'menelepon': 'telepon',
'meneleponnya': 'telepon',
'meneleponkan': 'telepon',
'meneleponi': 'telepon',
'meneleponku': 'telepon',
'meneleponmu': 'telepon',
'bertelepon': 'telepon',
'berteleponan': 'telepon',
'bertelepuk': 'telepuk',
'bertelepukan': 'telepuk',
'telesan': 'teles',
'pertelevisian': 'televisi',
'menelik': 'telik',
'penelik': 'telik',
'menelikung': 'telikung',
'menelikungnya': 'telikung',
'bertelimpuh': 'telimpuh',
'menelinga': 'telinga',
'bertelinga': 'telinga',
'bertelingkah': 'telingkah',
'tertelingkung': 'telingkung',
'meneliti': 'teliti',
'menelitinya': 'teliti',
'menelitian': 'teliti',
'peneliti': 'teliti',
'penelitinya': 'teliti',
'penelitikan': 'teliti',
'penelitii': 'teliti',
'penelitian': 'teliti',
'ketelitian': 'teliti',
'ketelitiannya': 'teliti',
'ketelitianlah': 'teliti',
'ketelitianmu': 'teliti',
'penelitiannya': 'teliti',
'penelitiani': 'teliti',
'penelitianku': 'teliti',
'berteluk': 'teluk',
'menelus': 'telus',
'menelusi': 'telus',
'menelusuk': 'telusuk',
'menelusuri': 'telusur',
'menelusurinya': 'telusur',
'penelusuran': 'telusur',
'penelusurannya': 'telusur',
'menelutut': 'telutut',
'mengetem': 'tem',
'mengetemkan': 'tem',
'bertema': 'tema',
'bertemakan': 'tema',
'temas-temas': 'temas',
'menembaga': 'tembaga',
'pertembakauan': 'tembakau',
'menembang': 'tembang',
'menembangnya': 'tembang',
'menembangkan': 'tembang',
'penembang': 'tembang',
'penembangnya': 'tembang',
'penembangkan': 'tembang',
'penembangan': 'tembang',
'menembis': 'tembis',
'menembok': 'tembok',
'menemboknya': 'tembok',
'temeh-temeh': 'temeh',
'menemin': 'temin',
'bertemin': 'temin',
'menempah': 'tempah',
'tempahan': 'tempah',
'menempap': 'tempap',
'setempap': 'tempap',
'bertempap': 'tempap',
'setempat': 'tempat',
'setempatnya': 'tempat',
'setempatlah': 'tempat',
'setempati': 'tempat',
'tempatan': 'tempat',
'bertempat': 'tempat',
'bertempatkan': 'tempat',
'bertempatan': 'tempat',
'menempati': 'tempat',
'menempatinya': 'tempat',
'menempatikan': 'tempat',
'menempatikannya': 'tempat',
'menempatii': 'tempat',
'ketempatan': 'tempat',
'penempatan': 'tempat',
'penempatannya': 'tempat',
'penempatanan': 'tempat',
'menempatkan': 'tempat',
'menempatkannya': 'tempat',
'menempatkankannya': 'tempat',
'menempatkanku': 'tempat',
'menempatkanmu': 'tempat',
'bertempat-tempat': 'tempat',
'setempat-setempat': 'tempat',
'menempelak': 'tempelak',
'menempelakkan': 'tempelak',
'tempelengan': 'tempeleng',
'menempeleng': 'tempeleng',
'menempelengnya': 'tempeleng',
'bertemperamen': 'temperamen',
'bertemperasan': 'temperas',
'bertemperau': 'temperau',
'bertempiar': 'tempiar',
'bertempiaran': 'tempiar',
'menempias': 'tempias',
'bertempias': 'tempias',
'tempikan': 'tempik',
'bertempik': 'tempik',
'menempikkan': 'tempik',
'menemplok': 'templok',
'tempo-tempo': 'tempo',
'bertempoh': 'tempoh',
'menempohkan': 'tempoh',
'menempong': 'tempong',
'setempuh': 'tempuh',
'menempuh': 'tempuh',
'menempuhnya': 'tempuh',
'menempuhi': 'tempuh',
'tertempuh': 'tempuh',
'ketempuhan': 'tempuh',
'menempuhkan': 'tempuh',
'bertempuh-tempuh': 'tempuh',
'menempulingi': 'tempuling',
'menemudugai': 'temu duga',
'menemu duga': 'temu duga',
'bertemu duga': 'temu duga',
'ketenagakerjaan': 'tenaga kerja',
'ketenagakerjaannya': 'tenaga kerja',
'ketenaganukliran': 'tenaga nuklir',
'ketenaran': 'tenar',
'ketenarannya': 'tenar',
'ketenaranku': 'tenar',
'menenarkan': 'tenar',
'menendas': 'tendas',
'menendaskan': 'tendas',
'bertendensi': 'tendensi',
'menenderkan': 'tender',
'menengadah': 'tengadah',
'menengadahkan': 'tengadah',
'menengarai': 'tengara',
'menengarainya': 'tengara',
'menenggak': 'tenggak',
'menenggaknya': 'tenggak',
'menenggakkan': 'tenggak',
'menenggakan': 'tenggak',
'tertenggan': 'tenggan',
'menenggang': 'tenggang',
'menenggangkan': 'tenggang',
'tertenggang': 'tenggang',
'bertenggang': 'tenggang',
'bertenggangan': 'tenggang',
'pertenggangan': 'tenggang',
'mempertenggangkan': 'tenggang',
'tenggang-menenggang': 'tenggang',
'bertenggang-tenggangan': 'tenggang',
'menenggara': 'tenggara',
'menenggarai': 'tenggara',
'tenggorokan': 'tenggorok',
'tenggorokannya': 'tenggorok',
'tenggorokanku': 'tenggorok',
'tenggorokanmu': 'tenggorok',
'menengil': 'tengil',
'menengkarapkan': 'tengkarap',
'menengkel': 'tengkel',
'bertengkelek': 'tengkelek',
'menengking': 'tengking',
'tengkingan': 'tengking',
'bertengking': 'tengking',
'setengkuk': 'tengkuk',
'bertengkuluk': 'tengkuluk',
'menengkurap': 'tengkurap',
'menengkurapkan': 'tengkurap',
'menengkurapkannya': 'tengkurap',
'menengok': 'tengok',
'menengoknya': 'tengok',
'menengokkan': 'tengok',
'menengoki': 'tengok',
'menengokan': 'tengok',
'menengokku': 'tengok',
'menengokmu': 'tengok',
'tengok-menengok': 'tengok',
'petenis': 'tenis',
'petenisnya': 'tenis',
'bertenjet': 'tenjet',
'menenok': 'tenok',
'ketentaraan': 'tentara',
'ketentaraannya': 'tentara',
'pertentaraan': 'tentara',
'menenteng': 'tenteng',
'menentengnya': 'tenteng',
'tenunan': 'tenun',
'tenunannya': 'tenun',
'penenun': 'tenun',
'penenunnya': 'tenun',
'penenunan': 'tenun',
'menenun': 'tenun',
'menenunnya': 'tenun',
'bertenun': 'tenun',
'pertenunan': 'tenun',
'penenung': 'tenung',
'penenungan': 'tenung',
'tenungan': 'tenung',
'menenung': 'tenung',
'bertenung': 'tenung',
'pertenungan': 'tenung',
'menepam': 'tepam',
'menepas': 'tepas',
'bertepas': 'tepas',
'menepasi': 'tepas',
'bertepat guna': 'tepat guna',
'tepian': 'tepi',
'tepiannya': 'tepi',
'bertepi': 'tepi',
'bertepikan': 'tepi',
'bertepian': 'tepi',
'menepikan': 'tepik',
'menepikannya': 'tepi',
'mengetepikan': 'tepi',
'menepik': 'tepik',
'tepukan': 'tepuk',
'tepukannya': 'tepuk',
'menepuk': 'tepuk',
'menepuknya': 'tepuk',
'menepukkan': 'tepuk',
'menepuki': 'tepuk',
'bertepuk': 'tepuk',
'menepungtawari': 'tepung tawar',
'peneral': 'teral',
'peneralan': 'teral',
'meneral': 'teral',
'berterali': 'terali',
'berteralikan': 'terali',
'keterampilan': 'terampil',
'keterampilannya': 'terampil',
'keterampilanku': 'terampil',
'menerampilkan': 'terampil',
'meneran': 'teran',
'menerankan': 'teran',
'menerangjelaskan': 'terang jelas',
'menerap': 'terap',
'menerapkan': 'terap',
'menerapkannya': 'terap',
'menerapi': 'terap',
'menerapan': 'terap',
'terapan': 'terap',
'terapannya': 'terap',
'penerap': 'terap',
'penerapnya': 'terap',
'penerapkan': 'terap',
'penerapi': 'terap',
'penerapan': 'terap',
'berterap': 'terap',
'penerapannya': 'terap',
'penerapanan': 'terap',
'menerapkankannya': 'terap',
'berteras': 'teras',
'berteraskan': 'teras',
'meneratak': 'teratak',
'meneratap': 'teratap',
'menerau': 'terau',
'menerawang': 'terawang',
'menerawangnya': 'terawang',
'menerawangkan': 'terawang',
'menerawangkannya': 'terawang',
'berterawang': 'terawang',
'menerbankan': 'terban',
'penerbit': 'terbit',
'penerbitnya': 'terbit',
'penerbitkan': 'terbit',
'penerbitan': 'terbit',
'terbitan': 'terbit',
'terbitannya': 'terbit',
'penerbitannya': 'terbit',
'menerbitkan': 'terbit',
'menerbitkannya': 'terbit',
'menerikkan': 'terik',
'menerika': 'terika',
'berterima kasih': 'terima kasih',
'menerindili': 'terindil',
'berteritik': 'teritik',
'menerjang': 'terjang',
'menerjangnya': 'terjang',
'menerjangan': 'terjang',
'penerjangan': 'terjang',
'menerjangkan': 'terjang',
'terjemahan': 'terjemah',
'terjemahannya': 'terjemah',
'terjemahanku': 'terjemah',
'penerjemah': 'terjemah',
'penerjemahnya': 'terjemah',
'penerjemahan': 'terjemah',
'penerjemahku': 'terjemah',
'penerjemahannya': 'terjemah',
'penerjemahanan': 'terjemah',
'menerjemahkan': 'terjemah',
'menerjemahkannya': 'terjemah',
'penerjun': 'terjun',
'penerjunnya': 'terjun',
'penerjunan': 'terjun',
'menerjuni': 'terjun',
'menerjuninya': 'terjun',
'keterjunan': 'terjun',
'beterjunan': 'terjun',
'penerjunannya': 'terjun',
'menerjunkan': 'terjun',
'menerjunkannya': 'terjun',
'menerjunkankan': 'terjun',
'menerka': 'terka',
'menerkanya': 'terka',
'terkaan': 'terka',
'penerka': 'terka',
'penerkaan': 'terka',
'menerkap': 'terkap',
'beterkup': 'terkup',
'menerkup': 'terkup',
'menerkupkan': 'terkup',
'menerok': 'terok',
'menerombol': 'terombol',
'meneropong': 'teropong',
'meneropongnya': 'teropong',
'meneropongi': 'teropong',
'meneror': 'teror',
'menerornya': 'teror',
'menerormu': 'teror',
'terubusan': 'terubus',
'menerumkan': 'terum',
'menerungku': 'terungku',
'menerungkukan': 'terungku',
'terutama': 'utama',
'terutamanya': 'utama',
'terutamakan': 'utama',
'keutamaan': 'utama',
'keutamaannya': 'utama',
'pengutamaan': 'utama',
'pengutamaannya': 'utama',
'mengutamakan': 'utama',
'mengutamakannya': 'utama',
'mengutamakankan': 'utama',
'mengetes': 'tes',
'mengetesnya': 'tes',
'mengeteskan': 'tes',
'pengetesan': 'tes',
'pengetesannya': 'tes',
'bertesmak': 'tesmak',
'menetal': 'tetal',
'ketetalan': 'tetal',
'menetalkan': 'tetal',
'penetap': 'tetap',
'penetapkan': 'tetap',
'penetapan': 'tetap',
'menetap': 'tetap',
'menetapnya': 'tetap',
'menetaplah': 'tetap',
'menetapkan': 'tetap',
'menetapkannya': 'tetap',
'menetapi': 'tetap',
'menetapan': 'tetap',
'menetapikan': 'tetap',
'penetapannya': 'tetap',
'penetapanan': 'tetap',
'ketetapan': 'tetap',
'ketetapannya': 'tetap',
'mempertetap': 'tetap',
'berketetapan': 'tetap',
'mempertetapkan': 'tetap',
'menetar': 'tetar',
'menetes': 'tetes',
'menetesnya': 'tetes',
'meneteslah': 'tetes',
'meneteskan': 'tetes',
'meneteskannya': 'tetes',
'menetesi': 'tetes',
'tetesan': 'tetes',
'tetesannya': 'tetes',
'bertetesan': 'tetes',
'tetua': 'tua',
'tetuanya': 'tua',
'menua': 'tua',
'menuanya': 'tua',
'menuakan': 'tua',
'menuaan': 'tua',
'tertua': 'tua',
'tertuanya': 'tua',
'tertuai': 'tua',
'tertuaku': 'tua',
'penuaan': 'tua',
'penuaannya': 'tua',
'penuaanku': 'tua',
'ketuaan': 'tua',
'tua-tua': 'tua',
'tua-tuaan': 'tua',
'pengetua': 'tua',
'bertua-tua': 'tua',
'ketua-tuaan': 'tua',
'bertua-tuaan': 'tua',
'tuang-tuang': 'tetuang',
'ketewasan': 'tewas',
'menewaskan': 'tewas',
'menewaskannya': 'tewas',
'menewaskankan': 'tewas',
'menewaskanmu': 'tewas',
'meniada': 'tiada',
'meniadakan': 'tiada',
'meniadakannya': 'tiada',
'ketiadaan': 'tiada',
'ketiadaannya': 'tiada',
'peniadaan': 'tiada',
'mempertiadakan': 'tiada',
'meniani': 'tian',
'bertian': 'tian',
'meniangpancangi': 'tiang pancang',
'setiap': 'tiap',
'setiapnya': 'tiap',
'meniapkan': 'tiap',
'tiap-tiap': 'tiap',
'tiap-tiapnya': 'tiap',
'menidakkan': 'tidak',
'setidaknya': 'tidak',
'setidaknyanya': 'tidak',
'mempertidak': 'tidak',
'tidak-tidak': 'tidak',
'tidak-tidaknya': 'tidak',
'mempertidakkan': 'tidak',
'setidak-tidaknya': 'tidak',
'setidak-tidaknyanya': 'tidak',
'menigari': 'tigari',
'menigas': 'tigas',
'mengetik': 'tik',
'mengetiknya': 'tik',
'mengetikkan': 'tik',
'mengetikkannya': 'tik',
'pengetik': 'tik',
'pengetikkan': 'tik',
'pengetikan': 'tik',
'tikan': 'tik',
'ketikan': 'tik',
'pengetikannya': 'tik',
'menika-nika': 'tika',
'menikas': 'tikas',
'bertikas': 'tikas',
'menikung': 'tikung',
'menikungnya': 'tikung',
'menikus': 'tikus',
'bertilam': 'tilam',
'menilang': 'tilang',
'menilangnya': 'tilang',
'tertilang': 'tilang',
'menilap': 'tilap',
'petilasan': 'tilas',
'mengetim': 'tim',
'pengetim': 'tim',
'pengetiman': 'tim',
'penimba': 'timba',
'menimba': 'timba',
'menimbanya': 'timba',
'tertimba': 'timba',
'bertimba': 'timba',
'penimbaan': 'timba',
'tertimbakan': 'timba',
'bertimbakan': 'timba',
'menimbau': 'timbau',
'menimbel': 'timbel',
'menimbrung': 'timbrung',
'menimbuk': 'timbuk',
'menimbukkan': 'timbuk',
'menimbukan': 'timbuk',
'penimbul': 'timbul',
'penimbulkan': 'timbul',
'penimbulan': 'timbul',
'menimbul': 'timbul',
'menimbulnya': 'timbul',
'menimbulkan': 'timbul',
'menimbulan': 'timbul',
'menimbulkani': 'timbul',
'timbunan': 'timbun',
'timbunannya': 'timbun',
'menimbun': 'timbun',
'menimbunnya': 'timbun',
'menimbunlah': 'timbun',
'menimbunkan': 'timbun',
'menimbuni': 'timbun',
'menimbunan': 'timbun',
'penimbun': 'timbun',
'penimbunnya': 'timbun',
'penimbunan': 'timbun',
'bertimbun': 'timbun',
'bertimbunlah': 'timbun',
'tertimbun': 'timbun',
'tertimbunnya': 'timbun',
'tertimbunan': 'timbun',
'penimbunannya': 'timbun',
'menimbun-nimbun': 'timbun',
'bertimbun-timbun': 'timbun',
'menimpang': 'timpang',
'ketimpangan': 'timpang',
'ketimpangannya': 'timpang',
'menimpangkan': 'timpang',
'tertimpang-timpang': 'timpang',
'menimpang-nimpangkan': 'timpang',
'bertimpas-timpas': 'timpas',
'bertimpuh': 'timpuh',
'menimpuk': 'timpuk',
'menimpuknya': 'timpuk',
'menimpukkan': 'timpuk',
'menimpuki': 'timpuk',
'menimpukinya': 'timpuk',
'timun-timunan': 'timun',
'menimur': 'timur',
'ketimuran': 'timur',
'ketimurannya': 'timur',
'menindaklanjuti': 'tindak lanjut',
'menindaklanjutinya': 'tindak lanjut',
'menindaklanjutii': 'tindak lanjut',
'menindan': 'tindan',
'bertindan': 'tindan',
'tindasan': 'tindas',
'penindas': 'tindas',
'penindasnya': 'tindas',
'penindasan': 'tindas',
'penindasmu': 'tindas',
'menindas': 'tindas',
'menindasnya': 'tindas',
'menindasku': 'tindas',
'tertindas': 'tindas',
'tertindasnya': 'tindas',
'penindasannya': 'tindas',
'ketertindasan': 'tindas',
'ketertindasannya': 'tindas',
'ditindih': 'tindih',
'ditindihi': 'tindih',
'tindihan': 'tindih',
'penindih': 'tindih',
'penindihan': 'tindih',
'menindih': 'tindih',
'menindihnya': 'tindih',
'menindihkan': 'tindih',
'menindihi': 'tindih',
'tertindih': 'tindih',
'bertindih': 'tindih',
'bertindihan': 'tindih',
'ketindihan': 'tindih',
'tindih-menindih': 'tindih',
'tindih-bertindih': 'tindih',
'meninggam': 'tinggam',
'meninggung': 'tinggung',
'bertinggung': 'tinggung',
'meningkap': 'tingkap',
'meningkapkan': 'tingkap',
'tingkapan': 'tingkap',
'meningkar': 'tingkar',
'meningkarnya': 'tingkar',
'meningkarkan': 'tingkar',
'tingkeban': 'tingkeb',
'bertingkrang': 'tingkrang',
'bertingkuh': 'tingkuh',
'peninju': 'tinju',
'peninjuan': 'tinju',
'meninju': 'tinju',
'meninjunya': 'tinju',
'meninjuku': 'tinju',
'petinju': 'tinju',
'petinjunya': 'tinju',
'bertinju': 'tinju',
'bertinjunya': 'tinju',
'pertinjuan': 'tinju',
'meninjukan': 'tinju',
'tinju-meninju': 'tinju',
'menintai': 'tinta',
'meninting': 'tinting',
'tintingan': 'tinting',
'menipis': 'tipis',
'menipisnya': 'tipis',
'menipislah': 'tipis',
'menipiskan': 'tipis',
'menipiskannya': 'tipis',
'menipisi': 'tipis',
'menipiskankan': 'tipis',
'tetirah': 'tirah',
'petirahan': 'tirah',
'tirakatan': 'tirakat',
'bertiras-tiras': 'tiras',
'tirisan': 'tiris',
'meniris': 'tiris',
'menirisnya': 'tiris',
'meniriskan': 'tiris',
'meniriskannya': 'tiris',
'penirisan': 'tiris',
'menirus': 'tirus',
'meniruskan': 'tirus',
'bertitah': 'titah',
'menitahkan': 'titah',
'menitahkannya': 'titah',
'tertitar-titar': 'titar',
'bertitar-titar': 'titar',
'menitar-nitarkan': 'titar',
'bertitel': 'titel',
'bertitelkan': 'titel',
'titian': 'titi',
'meniti': 'titi',
'menitinya': 'titi',
'menitip': 'titip',
'menitipkan': 'titip',
'menitipkannya': 'titip',
'menitipi': 'titip',
'menitipan': 'titip',
'penitip': 'titip',
'penitipnya': 'titip',
'penitipan': 'titip',
'titipan': 'titip',
'titipannya': 'titip',
'titipanlah': 'titip',
'titipanku': 'titip',
'titipanmu': 'titip',
'titipan-mu': 'titip',
'penitipannya': 'titip',
'menitipkankan': 'titip',
'menitir': 'titir',
'titiran': 'titir',
'meniup': 'tiup',
'meniupnya': 'tiup',
'meniuplah': 'tiup',
'meniupkan': 'tiup',
'meniupkannya': 'tiup',
'tiupan': 'tiup',
'tiupannya': 'tiup',
'tertiup': 'tiup',
'bertiup': 'tiup',
'bertiupnya': 'tiup',
'tiup-tiup': 'tiup',
'meniup-niup': 'tiup',
'meniup-niupnya': 'tiup',
'meniup-niupkan': 'tiup',
'meniwahkan': 'tiwah',
'bertiwikrama': 'tiwikrama',
'menobak': 'tobak',
'bertobak': 'tobak',
'bertobat': 'tobat',
'bertobatnya': 'tobat',
'bertobatlah': 'tobat',
'pertobatan': 'tobat',
'pertobatannya': 'tobat',
'bertoboh-toboh': 'toboh',
'menodong': 'todong',
'menodongnya': 'todong',
'menodongkan': 'todong',
'menodongkannya': 'todong',
'menodongku': 'todong',
'penodong': 'todong',
'penodongnya': 'todong',
'penodongan': 'todong',
'menogan': 'togan',
'menogelkan': 'togel',
'bertogok': 'togok',
'menohok': 'tohok',
'menohokkan': 'tohok',
'bertohor': 'tohor',
'ketohoran': 'tohor',
'menohorkan': 'tohor',
'menokak': 'tokak',
'tokak-takik': 'tokak',
'bertoko': 'toko',
'pertokoan': 'toko',
'pertokoannya': 'toko',
'menokong': 'tokong',
'bertolap': 'tolap',
'menoleh': 'toleh',
'menolehnya': 'toleh',
'menolehlah': 'toleh',
'menolehkan': 'toleh',
'pertolehan': 'toleh',
'penolok': 'tolok',
'penolokan': 'tolok',
'setolok': 'tolok',
'menolok': 'tolok',
'menomang': 'tomang',
'ketomboian': 'tomboi',
'menomboki': 'tombok',
'menombokinya': 'tombok',
'bertonase': 'tonase',
'menonggak': 'tonggak',
'bertonggok': 'tonggok',
'menonggokkan': 'tonggok',
'tongkahan': 'tongkah',
'menongkah': 'tongkah',
'penongkat': 'tongkat',
'menongkat': 'tongkat',
'bertongkat': 'tongkat',
'menongkatkan': 'tongkat',
'tongkrongan': 'tongkrong',
'tongkrongannya': 'tongkrong',
'menongkrong': 'tongkrong',
'menongkrongi': 'tongkrong',
'menongol': 'tongol',
'menongolkan': 'tongol',
'menonjok': 'tonjok',
'menonjoknya': 'tonjok',
'menonjokkan': 'tonjok',
'menonjoki': 'tonjok',
'menonjokan': 'tonjok',
'mengetop': 'top',
'menopek': 'topek',
'bertopi': 'topi',
'bertopik': 'topik',
'penopikan': 'topik',
'menopikkan': 'topik',
'menorpedo': 'torpedo',
'mengetos': 'tos',
'menotal': 'total',
'menotalkan': 'total',
'totol-totol': 'totol',
'totol-totolnya': 'totol',
'menoyor': 'toyor',
'menoyornya': 'toyor',
'mentradisi': 'tradisi',
'mentradisikan': 'tradisi',
'mentraktir': 'traktir',
'mentraktirnya': 'traktir',
'mentraktirmu': 'traktir',
'mentraktor': 'traktor',
'mentransfer': 'transfer',
'mentransfernya': 'transfer',
'mentransferkan': 'transfer',
'mentransformasikan': 'transformasi',
'mentransformasikannya': 'transformasi',
'pentranskripsi': 'transkripsi',
'pentranskripsian': 'transkripsi',
'mentranskripsikan': 'transkripsi',
'bertransmigrasi': 'transmigrasi',
'mentransmigrasikan': 'transmigrasi',
'mentransmigrasilokalkan': 'transmigrasi lokal',
'mentransmisikan': 'transmisi',
'mentransmisikannya': 'transmisi',
'tertransmisikan': 'transmisi',
'mentransmutasikan': 'transmutasi',
'mentransplantasikan': 'transplantasi',
'mentransplantasikannya': 'transplantasi',
'mentranspor': 'transpor',
'mengetren': 'tren',
'ketrengginasan': 'trengginas',
'triliunan': 'triliun',
'pentrompet': 'trompet',
'mentrompetkan': 'trompet',
'bertruk-truk': 'truk',
'menual': 'tual',
'menuali': 'tual',
'bertual-tual': 'tual',
'petualang': 'tualang',
'petualangnya': 'tualang',
'petualangan': 'tualang',
'bertualang': 'tualang',
'bertualangan': 'tualang',
'petualangannya': 'tualang',
'petualanganku': 'tualang',
'petualanganmu': 'tualang',
'pertualangan': 'tualang',
'pertualangannya': 'tualang',
'bertuan': 'tuan',
'bertuannya': 'tuan',
'menuani': 'tuan',
'pertuanan': 'tuan',
'menuankan': 'tuan',
'tuan-tuan': 'tuan',
'bertuankan': 'tuan',
'mempertuan': 'tuan',
'ketuan-tuanan': 'tuan',
'mempertuankan': 'tuan',
'menuanrumahi': 'tuan rumah',
'menuas': 'tuas',
'menuba': 'tuba',
'menubai': 'tuba',
'tuban-tuban': 'tuban',
'ketubruk': 'tubruk',
'menubruk': 'tubruk',
'menubruknya': 'tubruk',
'menubrukkan': 'tubruk',
'menubrukan': 'tubruk',
'menubrukku': 'tubruk',
'tubrukan': 'tubruk',
'tubrukannya': 'tubruk',
'tertubruk': 'tubruk',
'bertubrukan': 'tubruk',
'bertubrukannya': 'tubruk',
'menuding': 'tuding',
'menudingnya': 'tuding',
'menudingkan': 'tuding',
'menudingi': 'tuding',
'menudingan': 'tuding',
'tudingan': 'tuding',
'tudingannya': 'tuding',
'tudingani': 'tuding',
'menuding-nuding': 'tuding',
'menuding-nudingkan': 'tuding',
'menuduh': 'tuduh',
'menuduhnya': 'tuduh',
'menuduhlah': 'tuduh',
'menuduhkan': 'tuduh',
'menuduhku': 'tuduh',
'tuduhan': 'tuduh',
'tuduhannya': 'tuduh',
'tuduhanan': 'tuduh',
'tuduhanku': 'tuduh',
'penuduh': 'tuduh',
'penuduhnya': 'tuduh',
'penuduhan': 'tuduh',
'tertuduh': 'tuduh',
'tertuduhnya': 'tuduh',
'menudung': 'tudung',
'menudungi': 'tudung',
'penudung': 'tudung',
'tertudung': 'tudung',
'bertudung': 'tudung',
'penudungan': 'tudung',
'menudungkan': 'tudung',
'menugaskaryakan': 'tugas karya',
'petugas': 'tugas',
'petugasnya': 'tugas',
'petugaslah': 'tugas',
'petugasi': 'tugas',
'petugasan': 'tugas',
'bertugas': 'tugas',
'bertugasnya': 'tugas',
'bertugaslah': 'tugas',
'bertugasi': 'tugas',
'menugasi': 'tugas',
'menugasinya': 'tugas',
'penugasan': 'tugas',
'penugasannya': 'tugas',
'penugasanku': 'tugas',
'menugaskan': 'tugas',
'menugaskannya': 'tugas',
'tuguran': 'tugur',
'menuguri': 'tugur',
'menuil': 'tuil',
'menuilkan': 'tuil',
'menujuhbulani': 'tujuh bulan',
'tujuh bulanan': 'tujuh bulan',
'menujuh bulan': 'tujuh bulan',
'menujuh hari': 'tujuh hari',
'menukai': 'tukai',
'menukam': 'tukam',
'menukas': 'tukas',
'menukasnya': 'tukas',
'menukaskan': 'tukas',
'tukasan': 'tukas',
'menukasi': 'tukas',
'bertukas-tukas': 'tukas',
'menukik': 'tukik',
'menukiknya': 'tukik',
'menukikkan': 'tukik',
'bertukuk': 'tukuk',
'menulahi': 'tulah',
'ketulahan': 'tulah',
'menulang': 'tulang',
'menulangi': 'tulang',
'tertulang': 'tulang',
'bertulang': 'tulang',
'bertulangnya': 'tulang',
'penulangan': 'tulang',
'penulangannya': 'tulang',
'ketulangan': 'tulang',
'pertulangan': 'tulang',
'tulang-tulangan': 'tulang',
'ketulusan': 'tulus',
'ketulusannya': 'tulus',
'mengetum': 'tum',
'menumang': 'tumang',
'menumangkan': 'tumang',
'menumis': 'tumis',
'menumisnya': 'tumis',
'bertumis': 'tumis',
'menumisi': 'tumis',
'tumpahan': 'tumpah',
'tumpahannya': 'tumpah',
'menumpahi': 'tumpah',
'tertumpah': 'tumpah',
'tertumpahnya': 'tumpah',
'tertumpahkan': 'tumpah',
'ketumpahan': 'tumpah',
'penumpahan': 'tumpah',
'pertumpahan': 'tumpah',
'menumpahkan': 'tumpah',
'menumpahkannya': 'tumpah',
'menumpah-numpahkan': 'tumpah',
'setumpak': 'tumpak',
'bertumpak-tumpak': 'tumpak',
'menumpangsarikan': 'tumpang sari',
'ketumpangtindihan': 'tumpang-tindih',
'bertumpang-tindih': 'tumpang-tindih',
'menumpat': 'tumpat',
'tertumpat': 'tumpat',
'menumpatkan': 'tumpat',
'tumpengan': 'tumpeng',
'menumpil': 'tumpil',
'penumpil': 'tumpil',
'menumplakkan': 'tumplak',
'menumpuk': 'tumpuk',
'menumpuknya': 'tumpuk',
'menumpukkan': 'tumpuk',
'menumpuki': 'tumpuk',
'setumpuk': 'tumpuk',
'setumpuknya': 'tumpuk',
'tumpukan': 'tumpuk',
'tumpukannya': 'tumpuk',
'tertumpuk': 'tumpuk',
'tertumpuknya': 'tumpuk',
'penumpukanan': 'tumpuk',
'bertumpuk-tumpuk': 'tumpuk',
'bertumpuk-tumpukan': 'tumpuk',
'ketumpulan': 'tumpul',
'ketumpulannya': 'tumpul',
'menumpulkan': 'tumpul',
'menumpur': 'tumpur',
'menumpurkan': 'tumpur',
'tertumus': 'tumus',
'tertunam': 'tunam',
'menunas': 'tunas',
'bertunas': 'tunas',
'menunasi': 'tunas',
'pertunasan': 'tunas',
'bertundang': 'tundang',
'bertundangan': 'tundang',
'menundung': 'tundung',
'tundungan': 'tundung',
'menungau': 'tungau',
'penunggak': 'tunggak',
'penunggaknya': 'tunggak',
'penunggakkan': 'tunggak',
'penunggakan': 'tunggak',
'menunggak': 'tunggak',
'menunggaknya': 'tunggak',
'menunggaklah': 'tunggak',
'menunggakan': 'tunggak',
'tunggakan': 'tunggak',
'tunggakannya': 'tunggak',
'menunggal': 'tunggal',
'menunggalkan': 'tunggal',
'setunggal': 'tunggal',
'ketunggalan': 'tunggal',
'ketunggalannya': 'tunggal',
'menungganglanggangkan': 'tunggang langgang',
'menunggik': 'tunggik',
'tertunggik': 'tunggik',
'menunggikkan': 'tunggik',
'menungging': 'tungging',
'menunggingkan': 'tungging',
'setungging': 'tungging',
'bersetungging': 'tungging',
'menunggul': 'tunggul',
'menunggulkan': 'tunggul',
'menungguli': 'tunggul',
'tunggul-tunggul': 'tunggul',
'menungkai': 'tungkai',
'penungkul': 'tungkul',
'penungkulan': 'tungkul',
'menungkul': 'tungkul',
'menungkup': 'tungkup',
'tertungkup': 'tungkup',
'menungkupkan': 'tungkup',
'menungkus': 'tungkus',
'menunjal': 'tunjal',
'menunjam': 'tunjam',
'menunjamnya': 'tunjam',
'ketuntasan': 'tuntas',
'menuntaskan': 'tuntas',
'menuntaskannya': 'tuntas',
'menuntung': 'tuntung',
'menuntungkan': 'tuntung',
'menuntungkannya': 'tuntung',
'setuntung': 'tuntung',
'tertuntung': 'tuntung',
'menuntut': 'tuntut',
'menuntutnya': 'tuntut',
'menuntutlah': 'tuntut',
'menuntutkan': 'tuntut',
'menuntuti': 'tuntut',
'menuntutan': 'tuntut',
'menuntutku': 'tuntut',
'menuntutmu': 'tuntut',
'penuntut': 'tuntut',
'penuntutnya': 'tuntut',
'penuntutan': 'tuntut',
'tuntutan': 'tuntut',
'tuntutannya': 'tuntut',
'tuntutanan': 'tuntut',
'tuntutanku': 'tuntut',
'penuntutannya': 'tuntut',
'menunu': 'tunu',
'menunukan': 'tunu',
'tertunu': 'tunu',
'penunuan': 'tunu',
'tupai-tupaian': 'tupai',
'bertura-tura': 'tura',
'peturasan': 'turas',
'menurbakan': 'turba',
'turi-turian': 'turi',
'menurus': 'turus',
'menurusnya': 'turus',
'menuruskan': 'turus',
'menuruskannya': 'turus',
'menurusi': 'turus',
'menusir': 'tusir',
'bertutu': 'tutu',
'menutuh': 'tutuh',
'menutuhkan': 'tutuh',
'menutuk': 'tutuk',
'menutukan': 'tutuk',
'menutuli': 'tutul',
'menutulkan': 'tutul',
'tuyuk-tuyuk': 'tuyuk',
'menguani': 'uan',
'menguankan': 'uan',
'menguar': 'uar',
'menguarnya': 'uar',
'uar-uar': 'uar',
'penguaran': 'uar',
'menguar-uarkan': 'uar-uar',
'mengubah bentuk': 'ubah bentuk',
'pengubahbentukan': 'ubah bentuk',
'mengubang': 'ubang',
'mengubar': 'ubar',
'mengubarkan': 'ubar',
'ubatan': 'ubat',
'ubek-ubekan': 'ubek',
'mengubek-ubek': 'ubek',
'ubel-ubel': 'ubel',
'uberan': 'uber',
'penguber': 'uber',
'menguber': 'uber',
'penguberan': 'uber',
'menguber-uber': 'uber',
'mengubit-ubit': 'ubit',
'mengubrak-abrik': 'ubrak-abrik',
'ububan': 'ubub',
'pengubub': 'ubub',
'mengububi': 'ubub',
'pengububan': 'ubub',
'mengubung': 'ubung',
'mengubungkan': 'ubung',
'mengubungkannya': 'ubung',
'mengubungi': 'ubung',
'mengubungan': 'ubung',
'mengucek': 'ucek',
'menguceknya': 'ucek',
'mengucek-ucek': 'ucek',
'mengudak': 'udak',
'udap-udapan': 'udap',
'mengudar': 'udar',
'mengudari': 'udar',
'pengudaran': 'udar',
'mengudarkan': 'udar',
'mengudara': 'udara',
'mengudaranya': 'udara',
'mengudarakan': 'udara',
'mengudarakannya': 'udara',
'pengudaraan': 'udara',
'mengudek': 'udek',
'udutan': 'udut',
'mengudut': 'udut',
'pengudut': 'udut',
'berufuk': 'ufuk',
'keugaharian': 'ugahari',
'mengugemi': 'ugem',
'ugeran': 'uger',
'menguik': 'uik',
'menguik-uik': 'uik',
'menguis-uis': 'uis',
'ujaran': 'ujar',
'ujarannya': 'ujar',
'berujar': 'ujar',
'ujar-ujar': 'ujar',
'ujar-ujaran': 'ujar',
'mengujarkan': 'ujar',
'berujud': 'ujud',
'mengujud': 'ujud',
'mengujudkan': 'ujud',
'seujung': 'ujung',
'berujung': 'ujung',
'berujungnya': 'ujung',
'berujunglah': 'ujung',
'berujungan': 'ujung',
'pengujung': 'ujung',
'pengujungnya': 'ujung',
'pengujungan': 'ujung',
'mengujung': 'ujung',
'mengujungi': 'ujung',
'ukupan': 'ukup',
'berukup': 'ukup',
'pengukup': 'ukup',
'perukupan': 'ukup',
'mengukupi': 'ukup',
'pengukupan': 'ukup',
'berulah': 'ulah',
'ulakan': 'ulak',
'ulak-ulak': 'ulak',
'ulaman': 'ulam',
'berulam': 'ulam',
'ulam-ulam': 'ulam',
'berulang kali': 'ulang kali',
'berulang tahun': 'ulang tahun',
'berulang-alik': 'ulang-alik',
'mengular': 'ular',
'mengularnya': 'ular',
'mengularkan': 'ular',
'ular-ularan': 'ular',
'seulas': 'ulas',
'ulasan': 'ulas',
'ulasannya': 'ulas',
'diulas': 'ulas',
'diulasnya': 'ulas',
'diulaskan': 'ulas',
'diulaskannya': 'ulas',
'berulas': 'ulas',
'mengulas': 'ulas',
'mengulasnya': 'ulas',
'mengulaskan': 'ulas',
'mengulaskannya': 'ulas',
'mengulasi': 'ulas',
'pengulas': 'ulas',
'pengulasan': 'ulas',
'perulasan': 'ulas',
'mengulas-ulas': 'ulas',
'ulekan': 'ulek',
'ulekannya': 'ulek',
'mengulek': 'ulek',
'menguleknya': 'ulek',
'ulek-ulek': 'ulek',
'pengulekan': 'ulek',
'uleman': 'ulem',
'mengulemi': 'ulem',
'menguleni': 'ulen',
'mengules': 'ules',
'keuletan': 'ulet',
'keuletannya': 'ulet',
'keuletanlah': 'ulet',
'mengulik': 'ulik',
'menguliknya': 'ulik',
'berulit': 'ulit',
'mengulitkan': 'ulit',
'mengulit-ulit': 'ulit',
'berulos': 'ulos',
'pengulosan': 'ulos',
'beruluk salam': 'uluk salam',
'uluran': 'ulur',
'terulur': 'ulur',
'terulurnya': 'ulur',
'mengulur': 'ulur',
'mengulurnya': 'ulur',
'mengulurkan': 'ulur',
'penguluran': 'ulur',
'memperulur': 'ulur',
'mengulur-ulur': 'ulur',
'mengulur-ulurnya': 'ulur',
'menguman': 'uman',
'menguman-uman': 'uman',
'keumatan': 'umat',
'keumatannya': 'umat',
'pengumban': 'umban',
'terumbang-umbang': 'umbang',
'terumbang-ambing': 'umbang-ambing',
'mengumbang-ambingkan': 'umbang-ambing',
'mengumbar': 'umbar',
'mengumbarnya': 'umbar',
'mengumbarkan': 'umbar',
'pengumbaran': 'umbar',
'berumbi': 'umbi',
'umbi-umbian': 'umbi',
'umbi-umbiannya': 'umbi',
'umbul-umbul': 'umbul',
'umbul-umbulnya': 'umbul',
'mengumbut': 'umbut',
'berumpak': 'umpak',
'mengumpak': 'umpak',
'mengumpakan': 'umpak',
'pengumpak': 'umpak',
'mengumpak-umpak': 'umpak',
'umpatan': 'umpat',
'umpatannya': 'umpat',
'pengumpat': 'umpat',
'mengumpat': 'umpat',
'mengumpatnya': 'umpat',
'mengumpati': 'umpat',
'pengumpatan': 'umpat',
'umpetan': 'umpet',
'mengumpet': 'umpet',
'berumpuk': 'umpuk',
'berumun': 'umun',
'mengumun': 'umun',
'mengumunkan': 'umun',
'undakan': 'undak',
'mengundak': 'undak',
'mengundakan': 'undak',
'undak-undakan': 'undak',
'undak-undakannya': 'undak',
'berundak-undak': 'undak',
'berundan-undan': 'undan',
'mengunduh': 'unduh',
'mengunduhnya': 'unduh',
'mengunduhkan': 'unduh',
'memperundungkan': 'undung-undung',
'berundung-undung': 'undung-undung',
'mengungam': 'ungam',
'unggah ungguh': 'unggah',
'mengunggas': 'unggas',
'berunggut-unggut': 'unggut',
'mengungkah': 'ungkah',
'mengungkat-ungkat': 'ungkat',
'pengungkil': 'ungkil',
'pengungkilan': 'ungkil',
'mengungkil': 'ungkil',
'ungkulan': 'ungkul',
'berungkur-ungkuran': 'ungkur',
'pengungsi': 'ungsi',
'pengungsinya': 'ungsi',
'pengungsilah': 'ungsi',
'pengungsian': 'ungsi',
'mengungsi': 'ungsi',
'mengungsinya': 'ungsi',
'mengungsilah': 'ungsi',
'mengungsikan': 'ungsi',
'mengungsikannya': 'ungsi',
'mengungsian': 'ungsi',
'pengungsiannya': 'ungsi',
'keungu-unguan': 'ungu',
'beruniform': 'uniform',
'keuniversalan': 'universal',
'berunjuk rasa': 'unjuk rasa',
'pengunjuk rasa': 'unjuk rasa',
'mengunjun': 'unjun',
'mengunjuni': 'unjun',
'mengunjungkan': 'unjung',
'unjuran': 'unjur',
'belunjur': 'unjur',
'terunjur': 'unjur',
'mengunjur': 'unjur',
'mengunjurkan': 'unjur',
'mengunjutkan': 'unjut',
'untaian': 'untai',
'untaiannya': 'untai',
'beruntai': 'untai',
'teruntai': 'untai',
'menguntai': 'untai',
'menguntaikannya': 'untai',
'beruntaian': 'untai',
'beruntai-untai': 'untai',
'menguntal': 'untal',
'seuntil': 'until',
'menguntil': 'until',
'menguntir': 'untir',
'teruntuk': 'untuk',
'beruntuk': 'untuk',
'peruntukan': 'untuk',
'peruntukannya': 'untuk',
'menguntukkan': 'untuk',
'memperuntukkan': 'untuk',
'memperuntukkannya': 'untuk',
'mengunun': 'unun',
'berunyai': 'unyai',
'mengunyai': 'unyai',
'berunyai-unyai': 'unyai',
'mengupa-upa': 'upa',
'upaman': 'upam',
'terupam': 'upam',
'mengupam': 'upam',
'pengupam': 'upam',
'mengupar': 'upar',
'menguparkan': 'upar',
'terupaya': 'upaya',
'berupaya': 'upaya',
'berupayanya': 'upaya',
'berupayalah': 'upaya',
'berupayakan': 'upaya',
'pengupayaan': 'upaya',
'mengupayakan': 'upaya',
'mengupayakannya': 'upaya',
'seupaya-upaya': 'upaya',
'seupaya-upayanya': 'upaya',
'upih-upih': 'upih',
'berura-ura': 'ura-ura',
'mengurah': 'urah',
'mengurahi': 'urah',
'urakan': 'urak',
'urakannya': 'urak',
'berurap': 'urap',
'mengurap': 'urap',
'mengurapi': 'urap',
'beruras': 'uras',
'berurasi': 'uras',
'mengurasikan': 'uras',
'menguraskan': 'uras',
'berurat': 'urat',
'menguri': 'uri',
'mengurik': 'urik',
'mengurik-urik': 'urik',
'berurine': 'urine',
'uring-uringan': 'uring',
'uring-uringannya': 'uring',
'beruris-uris': 'uris',
'urukan': 'uruk',
'menguruk': 'uruk',
'menguruknya': 'uruk',
'mengurukan': 'uruk',
'pengurukan': 'uruk',
'pengurukannya': 'uruk',
'urunan': 'urun',
'urunannya': 'urun',
'urunanan': 'urun',
'berurung': 'urung',
'usahkan': 'usah',
'mengusaki': 'usak',
'berusali': 'usali',
'user-useran': 'user-user',
'usilan': 'usil',
'mengusil-usil': 'usil',
'mengusil-usilkan': 'usil',
'keusrekan': 'usrek',
'pengusutan': 'usut',
'pengusutannya': 'usut',
'mengutak-atik': 'utak-atik',
'mengutak-atiknya': 'utak-atik',
'utangan': 'utang',
'berutang': 'utang',
'berutangnya': 'utang',
'berutanglah': 'utang',
'mengutangi': 'utang',
'mengutanginya': 'utang',
'perutangan': 'utang',
'mengutangkan': 'utang',
'memperutangi': 'utang',
'memperutangkan': 'utang',
'utasan': 'utas',
'berutas': 'utas',
'pengutik': 'utik',
'pengutikan': 'utik',
'mengutik-utik': 'utik',
'menguyuh': 'uyuh',
'menguyuhi': 'uyuh',
'pervaginaan': 'vagina',
'bervakansi': 'vakansi',
'memvaksinasi': 'vaksinasi',
'memvaksinasinya': 'vaksinasi',
'memvaksinasikan': 'vaksinasi',
'kevakuman': 'vakum',
'pervalasan': 'valas',
'bervariasi': 'variasi',
'bervariasinya': 'variasi',
'memvariasikan': 'variasi',
'memvariasikannya': 'variasi',
'memveto': 'veto',
'memvetonya': 'veto',
'virus': 'visa',
'virusnya': 'visa',
'memvisualkan': 'visual',
'memvisualkannya': 'visual',
'memvisualisasikan': 'visualisasi',
'memvisualisasikannya': 'visualisasi',
'memvitalkan': 'vital',
'memvonis': 'vonis',
'memvonisnya': 'vonis',
'memvonisku': 'vonis',
'berwaad': 'waad',
'mewabah': 'wabah',
'mewabahnya': 'wabah',
'mewabahkan': 'wabah',
'mewabahi': 'wabah',
'mewadahi': 'wadah',
'mewadahinya': 'wadah',
'terwadahi': 'wadah',
'terwadahinya': 'wadah',
'berwadahkan': 'wadah',
'mewahyukan': 'wahyu',
'berwajah': 'wajah',
'berwajahkan': 'wajah',
'perwajahan': 'wajah',
'perwajahannya': 'wajah',
'berwakaf': 'wakaf',
'mewakafkan': 'wakaf',
'mewakafkannya': 'wakaf',
'berwakil': 'wakil',
'berwakilan': 'wakil',
'mewakili': 'wakil',
'mewakilinya': 'wakil',
'mewakilii': 'wakil',
'mewakiliku': 'wakil',
'terwakili': 'wakil',
'terwakilinya': 'wakil',
'mewakilkan': 'wakil',
'mewakilkannya': 'wakil',
'perwakilan': 'wakil',
'perwakilannya': 'wakil',
'perwakilani': 'wakil',
'perwakilanku': 'wakil',
'keterwakilan': 'wakil',
'keterwakilannya': 'wakil',
'sewaktu': 'waktu',
'berwaktu': 'waktu',
'pewaktuan': 'waktu',
'sewaktu-waktu': 'waktu',
'sewaktu-waktunya': 'waktu',
'terwalak': 'walak',
'mewalakkan': 'walak',
'kewangsaan': 'wangsa',
'wanita tunasusila': 'kewanitaan',
'wantahan': 'wantah',
'mewantek': 'wantek',
'pewantekan': 'wantek',
'mewanti-wanti': 'wanti-wanti',
'mewanti-wantinya': 'wanti-wanti',
'mewanti-wantikan': 'wanti-wanti',
'wara-wara': 'wara',
'pewaralaba': 'waralaba',
'pewaralabanya': 'waralaba',
'terwaralaba': 'waralaba',
'pewaralabaan': 'waralaba',
'kewargaan': 'warga',
'kewargaannya': 'warga',
'kewarganegaraan': 'warga negara',
'kewarganegaraannya': 'warga negara',
'kewarganegaraanku': 'warga negara',
'kewarganegaraanmu': 'warga negara',
'pewarganegaraan': 'warga negara',
'mewarganegarakan': 'warga negara',
'berwari': 'wari',
'berwarna-warni': 'warna-warni',
'berwarna-warninya': 'warna-warni',
'mewarna-warnikan': 'warna-warni',
'berwarung': 'warung',
'mewasiti': 'wasit',
'perwasitan': 'wasit',
'perwasitannya': 'wasit',
'kewaskitaan': 'waskita',
'mewaspadai': 'waspada',
'mewaspadainya': 'waspada',
'berwaspada': 'waspada',
'berwaspadalah': 'waspada',
'kewaspadaan': 'waspada',
'kewaspadaannya': 'waspada',
'kewaspadaanmu': 'waspada',
'mewaspadakan': 'waspada',
'berwaswas': 'waswas',
'pewatas': 'watas',
'mewatasi': 'watas',
'berwawanmuka': 'wawanmuka',
'berwawanrembuk': 'wawanrembuk',
'mewawas diri': 'wawas diri',
'mewawas': 'wawas',
'wawasan': 'wawas',
'wawasannya': 'wawas',
'wawasanmu': 'wawas',
'pewayang': 'wayang',
'pewayangan': 'wayang',
'wayangan': 'wayang',
'wayangannya': 'wayang',
'mewayangkan': 'wayang',
'kewedanaan': 'wedana',
'mewedar': 'wedar',
'wedaran': 'wedar',
'wedelan': 'wedel',
'mewedel': 'wedel',
'kewedukan': 'weduk',
'mewejang': 'wejang',
'wejangan': 'wejang',
'wejangannya': 'wejang',
'welasan': 'welas',
'welingan': 'weling',
'wewenang': 'wenang',
'wewenangnya': 'wenang',
'wewenanglah': 'wenang',
'wewenangkan': 'wenang',
'wewenangan': 'wenang',
'wewenangku': 'wenang',
'berwenang': 'wenang',
'berwenangnya': 'wenang',
'berwenanglah': 'wenang',
'berwenangkan': 'wenang',
'berwenangan': 'wenang',
'kewenangan': 'wenang',
'kewenangannya': 'wenang',
'kewenangankan': 'wenang',
'kewenanganan': 'wenang',
'kewenanganku': 'wenang',
'sewenang-wenang': 'wenang',
'sewenang-wenangnya': 'wenang',
'sewenang-wenangan': 'wenang',
'kesewenang-wenangan': 'wenang',
'kesewenang-wenangannya': 'wenang',
'kesewenang-wenanganan': 'wenang',
'wijikan': 'wijik',
'sewilayah': 'wilayah',
'sewilayahnya': 'wilayah',
'mewilayahi': 'wilayah',
'perwilayahan': 'wilayah',
'berwindu-windu': 'windu',
'sewingit': 'wingit',
'kewiraan': 'wira',
'berwiraswasta': 'wiraswasta',
'kewiraswastaan': 'wiraswasta',
'mewiraswastakan': 'wiraswasta',
'wiridan': 'wirid',
'mewiridkan': 'wirid',
'mewiru': 'wiru',
'mewirukan': 'wiru',
'berwiru-wiru': 'wiru',
'berwisata': 'wisata',
'berwisatanya': 'wisata',
'berwisatalah': 'wisata',
'mewismakan': 'wisma',
'mewisuda': 'wisuda',
'mewisudanya': 'wisuda',
'mewisudakan': 'wisuda',
'berwudu': 'wudu',
'mewujud': 'wujud',
'mewujudnya': 'wujud',
'mewujudkan': 'wujud',
'mewujudkannya': 'wujud',
'mewujudan': 'wujud',
'terwujud': 'wujud',
'terwujudnya': 'wujud',
'terwujudlah': 'wujud',
'terwujudkan': 'wujud',
'terwujudkannya': 'wujud',
'berwujud': 'wujud',
'pewujudan': 'wujud',
'pewujudannya': 'wujud',
'kewujudan': 'wujud',
'mewujudkankannya': 'wujud',
'perwujudan': 'wujud',
'perwujudannya': 'wujud',
'memperwujudkan': 'wujud',
'berwukuf': 'wukuf',
'wulangan': 'wulang',
'memperyahudikan': 'yahudi',
'meyakini': 'yakin',
'meyakininya': 'yakin',
'keyakinan': 'yakin',
'keyakinannya': 'yakin',
'keyakinanlah': 'yakin',
'keyakinanan': 'yakin',
'keyakinanku': 'yakin',
'keyakinanmu': 'yakin',
'meyakinkan': 'yakin',
'meyakinkannya': 'yakin',
'meyakinkankan': 'yakin',
'meyakinkanku': 'yakin',
'meyakinkanmu': 'yakin',
'berkeyakinan': 'yakin',
'berkeyakinannya': 'yakin',
'berkeyakinanan': 'yakin',
'meyakin-yakini': 'yakin',
'kun fa yakun': 'yakun',
'yang-yang': 'yang',
'yang-yangan': 'yang',
'beryang-yang': 'yang',
'beryoga': 'yoga',
'beryogalah': 'yoga',
'seyogianya': 'yogia',
'sezarah': 'zarah',
'menzarah': 'zarah',
'pezikir': 'zikir',
'berzikir': 'zikir',
'berzikirlah': 'zikir',
'berzikiri': 'zikir',
'perzonaan': 'zona'
}
|
from supplies.annotate import attr, delay, refer
__author__ = 'dwae'
class Test:
def __init__(self, cnt=0):
self.cnt = cnt
@attr
def foo(self):
cnt = self.cnt
self.cnt += 1
return cnt
@delay
def bar(self):
cnt = self.cnt
self.cnt += 1
return cnt
@refer
def baz(self):
cnt = self.cnt
self.cnt += 1
return cnt
def test_attr():
assert isinstance(Test.foo, attr)
t = Test()
assert t.foo == 0
assert t.foo == 1
t.foo = 42
assert t.foo == 42
assert t.foo == 42
assert t.bar == 2
assert t.bar == 2
del t.foo
assert t.foo == 3
assert t.foo == 4
assert t.bar == 2
del t.bar
assert t.bar == 5
assert t.bar == 5
assert t.foo == 6
assert t.baz == 7
assert t.baz == 7
import pickle
t_ = pickle.loads(pickle.dumps(t))
assert t.foo == 8
assert t_.foo == 8
assert t.bar == 5
assert t_.bar == 5
assert t.baz == 7
assert t_.baz == 9
|
# This file helps to compute a version number in source trees obtained from
# git-archive tarball (such as those provided by githubs download-from-tag
# feature). Distribution tarballs (built by setup.py sdist) and build
# directories (produced by setup.py build) will contain a much shorter file
# that just contains the computed version number.
# This file is released into the public domain. Generated by
# versioneer-0.18 (https://github.com/warner/python-versioneer)
"""Git implementation of _version.py."""
import errno
import os
import re
import subprocess
import sys
def get_keywords():
"""Get the keywords needed to look up the version information."""
# these strings will be replaced by git during git-archive.
# setup.py/versioneer.py will grep for the variable names, so they must
# each be defined on a line of their own. _version.py will just call
# get_keywords().
git_refnames = "$Format:%d$"
git_full = "$Format:%H$"
git_date = "$Format:%ci$"
keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
return keywords
class VersioneerConfig:
"""Container for Versioneer configuration parameters."""
def get_config():
"""Create, populate and return the VersioneerConfig() object."""
# these strings are filled in when 'setup.py versioneer' creates
# _version.py
cfg = VersioneerConfig()
cfg.VCS = "git"
cfg.style = ""
cfg.tag_prefix = ""
cfg.parentdir_prefix = "magic-wormhole"
cfg.versionfile_source = "src/wormhole/_version.py"
cfg.verbose = False
return cfg
class NotThisMethod(Exception):
"""Exception raised if a method is not valid for the current scenario."""
LONG_VERSION_PY = {}
HANDLERS = {}
def register_vcs_handler(vcs, method): # decorator
"""Decorator to mark a method as the handler for a particular VCS."""
def decorate(f):
"""Store f in HANDLERS[vcs][method]."""
if vcs not in HANDLERS:
HANDLERS[vcs] = {}
HANDLERS[vcs][method] = f
return f
return decorate
def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
env=None):
"""Call the given command(s)."""
assert isinstance(commands, list)
p = None
for c in commands:
try:
dispcmd = str([c] + args)
# remember shell=False, so use git.cmd on windows, not just git
p = subprocess.Popen([c] + args, cwd=cwd, env=env,
stdout=subprocess.PIPE,
stderr=(subprocess.PIPE if hide_stderr
else None))
break
except EnvironmentError:
e = sys.exc_info()[1]
if e.errno == errno.ENOENT:
continue
if verbose:
print("unable to run %s" % dispcmd)
print(e)
return None, None
else:
if verbose:
print("unable to find command, tried %s" % (commands,))
return None, None
stdout = p.communicate()[0].strip()
if sys.version_info[0] >= 3:
stdout = stdout.decode()
if p.returncode != 0:
if verbose:
print("unable to run %s (error)" % dispcmd)
print("stdout was %s" % stdout)
return None, p.returncode
return stdout, p.returncode
def versions_from_parentdir(parentdir_prefix, root, verbose):
"""Try to determine the version from the parent directory name.
Source tarballs conventionally unpack into a directory that includes both
the project name and a version string. We will also support searching up
two directory levels for an appropriately named parent directory
"""
rootdirs = []
for i in range(3):
dirname = os.path.basename(root)
if dirname.startswith(parentdir_prefix):
return {"version": dirname[len(parentdir_prefix):],
"full-revisionid": None,
"dirty": False, "error": None, "date": None}
else:
rootdirs.append(root)
root = os.path.dirname(root) # up a level
if verbose:
print("Tried directories %s but none started with prefix %s" %
(str(rootdirs), parentdir_prefix))
raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
@register_vcs_handler("git", "get_keywords")
def git_get_keywords(versionfile_abs):
"""Extract version information from the given file."""
# the code embedded in _version.py can just fetch the value of these
# keywords. When used from setup.py, we don't want to import _version.py,
# so we do it with a regexp instead. This function is not used from
# _version.py.
keywords = {}
try:
f = open(versionfile_abs, "r")
for line in f.readlines():
if line.strip().startswith("git_refnames ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["refnames"] = mo.group(1)
if line.strip().startswith("git_full ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["full"] = mo.group(1)
if line.strip().startswith("git_date ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["date"] = mo.group(1)
f.close()
except EnvironmentError:
pass
return keywords
@register_vcs_handler("git", "keywords")
def git_versions_from_keywords(keywords, tag_prefix, verbose):
"""Get version information from git keywords."""
if not keywords:
raise NotThisMethod("no keywords at all, weird")
date = keywords.get("date")
if date is not None:
# git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
# datestamp. However we prefer "%ci" (which expands to an "ISO-8601
# -like" string, which we must then edit to make compliant), because
# it's been around since git-1.5.3, and it's too difficult to
# discover which version we're using, or to work around using an
# older one.
date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
refnames = keywords["refnames"].strip()
if refnames.startswith("$Format"):
if verbose:
print("keywords are unexpanded, not using")
raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
refs = set([r.strip() for r in refnames.strip("()").split(",")])
# starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
# just "foo-1.0". If we see a "tag: " prefix, prefer those.
TAG = "tag: "
tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
if not tags:
# Either we're using git < 1.8.3, or there really are no tags. We use
# a heuristic: assume all version tags have a digit. The old git %d
# expansion behaves like git log --decorate=short and strips out the
# refs/heads/ and refs/tags/ prefixes that would let us distinguish
# between branches and tags. By ignoring refnames without digits, we
# filter out many common branch names like "release" and
# "stabilization", as well as "HEAD" and "master".
tags = set([r for r in refs if re.search(r'\d', r)])
if verbose:
print("discarding '%s', no digits" % ",".join(refs - tags))
if verbose:
print("likely tags: %s" % ",".join(sorted(tags)))
for ref in sorted(tags):
# sorting will prefer e.g. "2.0" over "2.0rc1"
if ref.startswith(tag_prefix):
r = ref[len(tag_prefix):]
if verbose:
print("picking %s" % r)
return {"version": r,
"full-revisionid": keywords["full"].strip(),
"dirty": False, "error": None,
"date": date}
# no suitable tags, so version is "0+unknown", but full hex is still there
if verbose:
print("no suitable tags, using unknown + full revision id")
return {"version": "0+unknown",
"full-revisionid": keywords["full"].strip(),
"dirty": False, "error": "no suitable tags", "date": None}
@register_vcs_handler("git", "pieces_from_vcs")
def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
"""Get version from 'git describe' in the root of the source tree.
This only gets called if the git-archive 'subst' keywords were *not*
expanded, and _version.py hasn't already been rewritten with a short
version string, meaning we're inside a checked out source tree.
"""
GITS = ["git"]
if sys.platform == "win32":
GITS = ["git.cmd", "git.exe"]
out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
hide_stderr=True)
if rc != 0:
if verbose:
print("Directory %s not under git control" % root)
raise NotThisMethod("'git rev-parse --git-dir' returned error")
# if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
# if there isn't one, this yields HEX[-dirty] (no NUM)
describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
"--always", "--long",
"--match", "%s*" % tag_prefix],
cwd=root)
# --long was added in git-1.5.5
if describe_out is None:
raise NotThisMethod("'git describe' failed")
describe_out = describe_out.strip()
full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
if full_out is None:
raise NotThisMethod("'git rev-parse' failed")
full_out = full_out.strip()
pieces = {}
pieces["long"] = full_out
pieces["short"] = full_out[:7] # maybe improved later
pieces["error"] = None
# parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
# TAG might have hyphens.
git_describe = describe_out
# look for -dirty suffix
dirty = git_describe.endswith("-dirty")
pieces["dirty"] = dirty
if dirty:
git_describe = git_describe[:git_describe.rindex("-dirty")]
# now we have TAG-NUM-gHEX or HEX
if "-" in git_describe:
# TAG-NUM-gHEX
mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
if not mo:
# unparseable. Maybe git-describe is misbehaving?
pieces["error"] = ("unable to parse git-describe output: '%s'"
% describe_out)
return pieces
# tag
full_tag = mo.group(1)
if not full_tag.startswith(tag_prefix):
if verbose:
fmt = "tag '%s' doesn't start with prefix '%s'"
print(fmt % (full_tag, tag_prefix))
pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"
% (full_tag, tag_prefix))
return pieces
pieces["closest-tag"] = full_tag[len(tag_prefix):]
# distance: number of commits since tag
pieces["distance"] = int(mo.group(2))
# commit: short hex revision ID
pieces["short"] = mo.group(3)
else:
# HEX: no tags
pieces["closest-tag"] = None
count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
cwd=root)
pieces["distance"] = int(count_out) # total number of commits
# commit date: see ISO-8601 comment in git_versions_from_keywords()
date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
cwd=root)[0].strip()
pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
return pieces
def plus_or_dot(pieces):
"""Return a + if we don't already have one, else return a ."""
if "+" in pieces.get("closest-tag", ""):
return "."
return "+"
def render_pep440(pieces):
"""Build up version string, with post-release "local version identifier".
Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
Exceptions:
1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += plus_or_dot(pieces)
rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
if pieces["dirty"]:
rendered += ".dirty"
else:
# exception #1
rendered = "0+untagged.%d.g%s" % (pieces["distance"],
pieces["short"])
if pieces["dirty"]:
rendered += ".dirty"
return rendered
def render_pep440_pre(pieces):
"""TAG[.post.devDISTANCE] -- No -dirty.
Exceptions:
1: no tags. 0.post.devDISTANCE
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"]:
rendered += ".post.dev%d" % pieces["distance"]
else:
# exception #1
rendered = "0.post.dev%d" % pieces["distance"]
return rendered
def render_pep440_post(pieces):
"""TAG[.postDISTANCE[.dev0]+gHEX] .
The ".dev0" means dirty. Note that .dev0 sorts backwards
(a dirty tree will appear "older" than the corresponding clean one),
but you shouldn't be releasing software with -dirty anyways.
Exceptions:
1: no tags. 0.postDISTANCE[.dev0]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += ".post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
rendered += plus_or_dot(pieces)
rendered += "g%s" % pieces["short"]
else:
# exception #1
rendered = "0.post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
rendered += "+g%s" % pieces["short"]
return rendered
def render_pep440_old(pieces):
"""TAG[.postDISTANCE[.dev0]] .
The ".dev0" means dirty.
Eexceptions:
1: no tags. 0.postDISTANCE[.dev0]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += ".post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
else:
# exception #1
rendered = "0.post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
return rendered
def render_git_describe(pieces):
"""TAG[-DISTANCE-gHEX][-dirty].
Like 'git describe --tags --dirty --always'.
Exceptions:
1: no tags. HEX[-dirty] (note: no 'g' prefix)
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"]:
rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
else:
# exception #1
rendered = pieces["short"]
if pieces["dirty"]:
rendered += "-dirty"
return rendered
def render_git_describe_long(pieces):
"""TAG-DISTANCE-gHEX[-dirty].
Like 'git describe --tags --dirty --always -long'.
The distance/hash is unconditional.
Exceptions:
1: no tags. HEX[-dirty] (note: no 'g' prefix)
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
else:
# exception #1
rendered = pieces["short"]
if pieces["dirty"]:
rendered += "-dirty"
return rendered
def render(pieces, style):
"""Render the given version pieces into the requested style."""
if pieces["error"]:
return {"version": "unknown",
"full-revisionid": pieces.get("long"),
"dirty": None,
"error": pieces["error"],
"date": None}
if not style or style == "default":
style = "pep440" # the default
if style == "pep440":
rendered = render_pep440(pieces)
elif style == "pep440-pre":
rendered = render_pep440_pre(pieces)
elif style == "pep440-post":
rendered = render_pep440_post(pieces)
elif style == "pep440-old":
rendered = render_pep440_old(pieces)
elif style == "git-describe":
rendered = render_git_describe(pieces)
elif style == "git-describe-long":
rendered = render_git_describe_long(pieces)
else:
raise ValueError("unknown style '%s'" % style)
return {"version": rendered, "full-revisionid": pieces["long"],
"dirty": pieces["dirty"], "error": None,
"date": pieces.get("date")}
def get_versions():
"""Get version information or return default if unable to do so."""
# I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
# __file__, we can work backwards from there to the root. Some
# py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
# case we can only use expanded keywords.
cfg = get_config()
verbose = cfg.verbose
try:
return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
verbose)
except NotThisMethod:
pass
try:
root = os.path.realpath(__file__)
# versionfile_source is the relative path from the top of the source
# tree (where the .git directory might live) to this file. Invert
# this to find the root from __file__.
for _ in cfg.versionfile_source.split('/'):
root = os.path.dirname(root)
except NameError:
return {"version": "0+unknown", "full-revisionid": None,
"dirty": None,
"error": "unable to find root of source tree",
"date": None}
try:
pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
return render(pieces, cfg.style)
except NotThisMethod:
pass
try:
if cfg.parentdir_prefix:
return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
except NotThisMethod:
pass
return {"version": "0+unknown", "full-revisionid": None,
"dirty": None,
"error": "unable to compute version", "date": None}
|
import datetime
import json
import random
from peewee import *
from peewee import sqlite3
from playhouse.sqlite_ext import SqliteExtDatabase
from playhouse.sqlite_udf import register_all
from .base import IS_SQLITE_9
from .base import ModelTestCase
from .base import TestModel
from .base import db_loader
from .base import skip_unless
try:
from playhouse import _sqlite_ext as cython_ext
except ImportError:
cython_ext = None
try:
from playhouse import _sqlite_udf as cython_udf
except ImportError:
cython_udf = None
def requires_cython(method):
return skip_unless(cython_udf is not None,
'requires sqlite udf c extension')(method)
database = db_loader('sqlite')
register_all(database)
class User(TestModel):
username = TextField()
class APIResponse(TestModel):
url = TextField(default='')
data = TextField(default='')
timestamp = DateTimeField(default=datetime.datetime.now)
class Generic(TestModel):
value = IntegerField(default=0)
x = Field(null=True)
MODELS = [User, APIResponse, Generic]
class FixedOffset(datetime.tzinfo):
def __init__(self, offset, name, dstoffset=42):
if isinstance(offset, int):
offset = datetime.timedelta(minutes=offset)
if isinstance(dstoffset, int):
dstoffset = datetime.timedelta(minutes=dstoffset)
self.__offset = offset
self.__name = name
self.__dstoffset = dstoffset
def utcoffset(self, dt):
return self.__offset
def tzname(self, dt):
return self.__name
def dst(self, dt):
return self.__dstoffset
class BaseTestUDF(ModelTestCase):
database = database
def sql1(self, sql, *params):
cursor = self.database.execute_sql(sql, params)
return cursor.fetchone()[0]
class TestAggregates(BaseTestUDF):
requires = [Generic]
def _store_values(self, *values):
with self.database.atomic():
for value in values:
Generic.create(x=value)
def mts(self, seconds):
return (datetime.datetime(2015, 1, 1) +
datetime.timedelta(seconds=seconds))
def test_min_avg_tdiff(self):
self.assertEqual(self.sql1('select mintdiff(x) from generic;'), None)
self.assertEqual(self.sql1('select avgtdiff(x) from generic;'), None)
self._store_values(self.mts(10))
self.assertEqual(self.sql1('select mintdiff(x) from generic;'), None)
self.assertEqual(self.sql1('select avgtdiff(x) from generic;'), 0)
self._store_values(self.mts(15))
self.assertEqual(self.sql1('select mintdiff(x) from generic;'), 5)
self.assertEqual(self.sql1('select avgtdiff(x) from generic;'), 5)
self._store_values(
self.mts(22),
self.mts(52),
self.mts(18),
self.mts(41),
self.mts(2),
self.mts(33))
self.assertEqual(self.sql1('select mintdiff(x) from generic;'), 3)
self.assertEqual(
round(self.sql1('select avgtdiff(x) from generic;'), 1),
7.1)
self._store_values(self.mts(22))
self.assertEqual(self.sql1('select mintdiff(x) from generic;'), 0)
def test_duration(self):
self.assertEqual(self.sql1('select duration(x) from generic;'), None)
self._store_values(self.mts(10))
self.assertEqual(self.sql1('select duration(x) from generic;'), 0)
self._store_values(self.mts(15))
self.assertEqual(self.sql1('select duration(x) from generic;'), 5)
self._store_values(
self.mts(22),
self.mts(11),
self.mts(52),
self.mts(18),
self.mts(41),
self.mts(2),
self.mts(33))
self.assertEqual(self.sql1('select duration(x) from generic;'), 50)
@requires_cython
def test_median(self):
self.assertEqual(self.sql1('select median(x) from generic;'), None)
self._store_values(1)
self.assertEqual(self.sql1('select median(x) from generic;'), 1)
self._store_values(3, 6, 6, 6, 7, 7, 7, 7, 12, 12, 17)
self.assertEqual(self.sql1('select median(x) from generic;'), 7)
Generic.delete().execute()
self._store_values(9, 2, 2, 3, 3, 1)
self.assertEqual(self.sql1('select median(x) from generic;'), 3)
Generic.delete().execute()
self._store_values(4, 4, 1, 8, 2, 2, 5, 8, 1)
self.assertEqual(self.sql1('select median(x) from generic;'), 4)
def test_mode(self):
self.assertEqual(self.sql1('select mode(x) from generic;'), None)
self._store_values(1)
self.assertEqual(self.sql1('select mode(x) from generic;'), 1)
self._store_values(4, 5, 6, 1, 3, 4, 1, 4, 9, 3, 4)
self.assertEqual(self.sql1('select mode(x) from generic;'), 4)
def test_ranges(self):
self.assertEqual(self.sql1('select minrange(x) from generic'), None)
self.assertEqual(self.sql1('select avgrange(x) from generic'), None)
self.assertEqual(self.sql1('select range(x) from generic'), None)
self._store_values(1)
self.assertEqual(self.sql1('select minrange(x) from generic'), 0)
self.assertEqual(self.sql1('select avgrange(x) from generic'), 0)
self.assertEqual(self.sql1('select range(x) from generic'), 0)
self._store_values(4, 8, 13, 19)
self.assertEqual(self.sql1('select minrange(x) from generic'), 3)
self.assertEqual(self.sql1('select avgrange(x) from generic'), 4.5)
self.assertEqual(self.sql1('select range(x) from generic'), 18)
Generic.delete().execute()
self._store_values(19, 4, 5, 20, 5, 8)
self.assertEqual(self.sql1('select range(x) from generic'), 16)
class TestScalarFunctions(BaseTestUDF):
requires = MODELS
def test_if_then_else(self):
for i in range(4):
User.create(username='u%d' % (i + 1))
with self.assertQueryCount(1):
query = (User
.select(
User.username,
fn.if_then_else(
User.username << ['u1', 'u2'],
'one or two',
'other').alias('name_type'))
.order_by(User.id))
self.assertEqual([row.name_type for row in query], [
'one or two',
'one or two',
'other',
'other'])
def test_strip_tz(self):
dt = datetime.datetime(2015, 1, 1, 12, 0)
# 13 hours, 37 minutes.
dt_tz = dt.replace(tzinfo=FixedOffset(13 * 60 + 37, 'US/LFK'))
api_dt = APIResponse.create(timestamp=dt)
api_dt_tz = APIResponse.create(timestamp=dt_tz)
# Re-fetch from the database.
api_dt_db = APIResponse.get(APIResponse.id == api_dt.id)
api_dt_tz_db = APIResponse.get(APIResponse.id == api_dt_tz.id)
# Assert the timezone is present, first of all, and that they were
# stored in the database.
self.assertEqual(api_dt_db.timestamp, dt)
query = (APIResponse
.select(
APIResponse.id,
fn.strip_tz(APIResponse.timestamp).alias('ts'))
.order_by(APIResponse.id))
ts, ts_tz = query[:]
self.assertEqual(ts.ts, dt)
self.assertEqual(ts_tz.ts, dt)
def test_human_delta(self):
values = [0, 1, 30, 300, 3600, 7530, 300000]
for value in values:
Generic.create(value=value)
delta = fn.human_delta(Generic.value).coerce(False)
query = (Generic
.select(
Generic.value,
delta.alias('delta'))
.order_by(Generic.value))
results = query.tuples()[:]
self.assertEqual(results, [
(0, '0 seconds'),
(1, '1 second'),
(30, '30 seconds'),
(300, '5 minutes'),
(3600, '1 hour'),
(7530, '2 hours, 5 minutes, 30 seconds'),
(300000, '3 days, 11 hours, 20 minutes'),
])
def test_file_ext(self):
data = (
('test.py', '.py'),
('test.x.py', '.py'),
('test', ''),
('test.', '.'),
('/foo.bar/test/nug.py', '.py'),
('/foo.bar/test/nug', ''),
)
for filename, ext in data:
res = self.sql1('SELECT file_ext(?)', filename)
self.assertEqual(res, ext)
def test_gz(self):
random.seed(1)
A = ord('A')
z = ord('z')
with self.database.atomic():
def randstr(l):
return ''.join([
chr(random.randint(A, z))
for _ in range(l)])
data = (
'a',
'a' * 1024,
randstr(1024),
randstr(4096),
randstr(1024 * 64))
for s in data:
compressed = self.sql1('select gzip(?)', s)
decompressed = self.sql1('select gunzip(?)', compressed)
self.assertEqual(decompressed.decode('utf-8'), s)
def test_hostname(self):
r = json.dumps({'success': True})
data = (
('https://charlesleifer.com/api/', r),
('https://a.charlesleifer.com/api/foo', r),
('www.nugget.com', r),
('nugz.com', r),
('http://a.b.c.peewee/foo', r),
('https://charlesleifer.com/xx', r),
('https://charlesleifer.com/xx', r),
)
with self.database.atomic():
for url, response in data:
APIResponse.create(url=url, data=data)
with self.assertQueryCount(1):
query = (APIResponse
.select(
fn.hostname(APIResponse.url).alias('host'),
fn.COUNT(APIResponse.id).alias('count'))
.group_by(fn.hostname(APIResponse.url))
.order_by(
fn.COUNT(APIResponse.id).desc(),
fn.hostname(APIResponse.url)))
results = query.tuples()[:]
self.assertEqual(results, [
('charlesleifer.com', 3),
('', 2),
('a.b.c.peewee', 1),
('a.charlesleifer.com', 1)])
@skip_unless(IS_SQLITE_9, 'requires sqlite >= 3.9')
def test_toggle(self):
self.assertEqual(self.sql1('select toggle(?)', 'foo'), 1)
self.assertEqual(self.sql1('select toggle(?)', 'bar'), 1)
self.assertEqual(self.sql1('select toggle(?)', 'foo'), 0)
self.assertEqual(self.sql1('select toggle(?)', 'foo'), 1)
self.assertEqual(self.sql1('select toggle(?)', 'bar'), 0)
self.assertEqual(self.sql1('select clear_toggles()'), None)
self.assertEqual(self.sql1('select toggle(?)', 'foo'), 1)
def test_setting(self):
self.assertEqual(self.sql1('select setting(?, ?)', 'k1', 'v1'), 'v1')
self.assertEqual(self.sql1('select setting(?, ?)', 'k2', 'v2'), 'v2')
self.assertEqual(self.sql1('select setting(?)', 'k1'), 'v1')
self.assertEqual(self.sql1('select setting(?, ?)', 'k2', 'v2-x'), 'v2-x')
self.assertEqual(self.sql1('select setting(?)', 'k2'), 'v2-x')
self.assertEqual(self.sql1('select setting(?)', 'kx'), None)
self.assertEqual(self.sql1('select clear_settings()'), None)
self.assertEqual(self.sql1('select setting(?)', 'k1'), None)
def test_random_range(self):
vals = ((1, 10), (1, 100), (0, 2), (1, 5, 2))
results = []
for params in vals:
random.seed(1)
results.append(random.randrange(*params))
for params, expected in zip(vals, results):
random.seed(1)
if len(params) == 3:
pstr = '?, ?, ?'
else:
pstr = '?, ?'
self.assertEqual(
self.sql1('select randomrange(%s)' % pstr, *params),
expected)
def test_sqrt(self):
self.assertEqual(self.sql1('select sqrt(?)', 4), 2)
self.assertEqual(round(self.sql1('select sqrt(?)', 2), 2), 1.41)
def test_tonumber(self):
data = (
('123', 123),
('1.23', 1.23),
('1e4', 10000),
('-10', -10),
('x', None),
('13d', None),
)
for inp, outp in data:
self.assertEqual(self.sql1('select tonumber(?)', inp), outp)
@requires_cython
def test_leven(self):
self.assertEqual(
self.sql1('select levenshtein_dist(?, ?)', 'abc', 'ba'),
2)
self.assertEqual(
self.sql1('select levenshtein_dist(?, ?)', 'abcde', 'eba'),
4)
self.assertEqual(
self.sql1('select levenshtein_dist(?, ?)', 'abcde', 'abcde'),
0)
@requires_cython
def test_str_dist(self):
self.assertEqual(
self.sql1('select str_dist(?, ?)', 'abc', 'ba'),
3)
self.assertEqual(
self.sql1('select str_dist(?, ?)', 'abcde', 'eba'),
6)
self.assertEqual(
self.sql1('select str_dist(?, ?)', 'abcde', 'abcde'),
0)
def test_substr_count(self):
self.assertEqual(
self.sql1('select substr_count(?, ?)', 'foo bar baz', 'a'), 2)
self.assertEqual(
self.sql1('select substr_count(?, ?)', 'foo bor baz', 'o'), 3)
self.assertEqual(
self.sql1('select substr_count(?, ?)', 'foodooboope', 'oo'), 3)
self.assertEqual(self.sql1('select substr_count(?, ?)', 'xx', ''), 0)
self.assertEqual(self.sql1('select substr_count(?, ?)', '', ''), 0)
def test_strip_chars(self):
self.assertEqual(
self.sql1('select strip_chars(?, ?)', ' hey foo ', ' '),
'hey foo')
@skip_unless(cython_ext is not None, 'requires sqlite c extension')
@skip_unless(sqlite3.sqlite_version_info >= (3, 9), 'requires sqlite >= 3.9')
class TestVirtualTableFunctions(ModelTestCase):
database = database
requires = MODELS
def sqln(self, sql, *p):
cursor = self.database.execute_sql(sql, p)
return cursor.fetchall()
def test_regex_search(self):
usernames = [
'charlie',
'hu3y17',
'zaizee2012',
'1234.56789',
'hurr durr']
for username in usernames:
User.create(username=username)
rgx = '[0-9]+'
results = self.sqln(
('SELECT user.username, regex_search.match '
'FROM user, regex_search(?, user.username) '
'ORDER BY regex_search.match'),
rgx)
self.assertEqual([row for row in results], [
('1234.56789', '1234'),
('hu3y17', '17'),
('zaizee2012', '2012'),
('hu3y17', '3'),
('1234.56789', '56789'),
])
def test_date_series(self):
ONE_DAY = 86400
def assertValues(start, stop, step_seconds, expected):
results = self.sqln('select * from date_series(?, ?, ?)',
start, stop, step_seconds)
self.assertEqual(results, expected)
assertValues('2015-01-01', '2015-01-05', 86400, [
('2015-01-01',),
('2015-01-02',),
('2015-01-03',),
('2015-01-04',),
('2015-01-05',),
])
assertValues('2015-01-01', '2015-01-05', 86400 / 2, [
('2015-01-01 00:00:00',),
('2015-01-01 12:00:00',),
('2015-01-02 00:00:00',),
('2015-01-02 12:00:00',),
('2015-01-03 00:00:00',),
('2015-01-03 12:00:00',),
('2015-01-04 00:00:00',),
('2015-01-04 12:00:00',),
('2015-01-05 00:00:00',),
])
assertValues('14:20:15', '14:24', 30, [
('14:20:15',),
('14:20:45',),
('14:21:15',),
('14:21:45',),
('14:22:15',),
('14:22:45',),
('14:23:15',),
('14:23:45',),
])
|
from base64 import b64encode
from urllib.parse import parse_qs, urlsplit
import uuid
from funnel.models import AuthToken
def test_authcode_requires_login(client):
"""The authcode endpoint requires a login."""
rv = client.get('/api/1/auth')
assert rv.status_code == 302
assert urlsplit(rv.location).path == '/login'
def test_authcode_wellformed(client, user_rincewind, client_hex, client_hex_credential):
"""The authcode endpoint will raise 403 if not well formed."""
# Add a userid to the session (using legacy handler) to create a user login
with client.session_transaction() as session:
session['userid'] = user_rincewind.userid
# Incomplete request
query_params = {}
rv = client.get('/api/1/auth', query_string=query_params)
assert rv.status_code == 403
assert "Missing client_id" in rv.get_data(as_text=True)
# Unknown client
query_params['client_id'] = 'unknown'
rv = client.get('/api/1/auth', query_string=query_params)
assert rv.status_code == 403
assert "Unknown client_id" in rv.get_data(as_text=True)
# Missing redirect URI (error is sent to client as a query parameter)
query_params['client_id'] = client_hex_credential.cred.name
rv = client.get('/api/1/auth', query_string=query_params)
assert rv.status_code == 303
assert parse_qs(urlsplit(rv.location).query)['error'] == ['invalid_request']
# TODO: Add redirect_uri, response_type, state, scope
def test_auth_untrusted_confidential(
db_session, client, user_rincewind, client_hex, client_hex_credential
):
"""Test auth on an untrusted confidential auth client."""
# Add a userid to the session (using legacy handler) to create a user login
with client.session_transaction() as session:
session['userid'] = user_rincewind.userid
# Get a CSRF token
csrf_token = client.get('/api/baseframe/1/csrf/refresh').get_data(as_text=True)
# --- Create a typical auth code request -------------------------------------------
authcode_params = {
'client_id': client_hex_credential.cred.name,
'response_type': 'code',
'state': str(uuid.uuid4()),
'scope': 'id',
'redirect_uri': client_hex.redirect_uri,
}
rv = client.get(
'/api/1/auth',
query_string=authcode_params,
)
# We got an auth page
assert rv.status_code == 200
# There is no existing AuthToken for this client and user
assert AuthToken.get_for(client_hex, user=user_rincewind) is None
# Submit form with `accept` and CSRF token
rv = client.post(
'/api/1/auth',
query_string=authcode_params,
data={'accept': '', 'csrf_token': csrf_token},
)
assert rv.status_code == 303
rparams = parse_qs(urlsplit(rv.location).query)
assert rparams['state'] == [authcode_params['state']]
code = rparams['code'][0]
assert code is not None
# --- Exchange code for a token ----------------------------------------------------
authtoken_params = {
'grant_type': 'authorization_code',
'code': code,
# For verification, the scope and redirect URI must be presented again
'scope': authcode_params['scope'],
'redirect_uri': authcode_params['redirect_uri'],
}
auth_header = (
'Basic '
+ b64encode(
(
client_hex_credential.cred.name + ':' + client_hex_credential.secret
).encode()
).decode()
)
rv = client.post(
'/api/1/token',
headers={'Authorization': auth_header},
data=authtoken_params,
)
assert rv.status_code == 200
data = rv.get_json()
# Confirm we have an access token
assert data['token_type'] == 'bearer'
assert data['access_token'] is not None
assert data['scope'] == authtoken_params['scope']
authtoken = AuthToken.get_for(client_hex, user=user_rincewind)
assert authtoken.token == data['access_token']
assert authtoken.token_type == data['token_type']
# --- Ask for an auth code again, with the same scope ------------------------------
authcode_params['state'] = str(uuid.uuid4())
rv = client.get(
'/api/1/auth',
query_string=authcode_params,
)
# This time there is no authorization page asking for user permission. We got
# a redirect back, with the authcode
assert rv.status_code == 303
rparams = parse_qs(urlsplit(rv.location).query)
assert rparams['code'][0] is not None
# However, increasing the scope requires authorization once again
authcode_params['state'] = str(uuid.uuid4())
authcode_params['scope'] = 'id email'
rv = client.get(
'/api/1/auth',
query_string=authcode_params,
)
assert rv.status_code == 200
# TODO: Test flow for trusted auth clients, and for public (non-confidential) clients
|
# Make a grid with all equilateral triangles
# Currently only supports a rectangular domain, constant density,
# and either vertical or horizontal orientation
import trigrid
import numpy as np
class EquilateralPaver(trigrid.TriGrid):
def __init__(self,L,W,dens,orientation='horizontal',**kwargs):
super(EquilateralPaver,self).__init__(**kwargs)
self.L = L # x dimension
self.W = W # y dimension
self.dens = dens
self.orientation = orientation
if self.orientation == 'vertical':
self.L,self.W = self.W,self.L
self.create_grid()
if self.orientation == 'vertical':
self.L,self.W = self.W,self.L
self.points = self.points[:,::-1]
self.cells = self.cells[:,::-1]
self.renumber()
def create_grid(self):
# first, how many rows - here we assume orientation is horizontal,
# so the left and right sides are ragged.
cos30 = np.cos(30*np.pi/180.)
n_rows = self.W / (cos30 * self.dens)
# to make sure that the first and last points line up, we need an
# even number of rows of cells:
n_rows = 2 * int( (n_rows+1.0)/ 2 )
self.n_rows = n_rows
# Let the length L be fudge-able - as in we prefer perfectly equilateral triangles
# over a perfectly L-length grid. the width W can still be exact.
dens = self.W / (n_rows * cos30)
print "That will make n_rows=%d and adjusted edge length %f"%(n_rows,dens)
# this is the number of cells...
n_cols = int(self.L / dens)
self.n_cols = n_cols
# Stack them up
for r in range(n_rows+1):
y = self.W * float(r)/n_rows
odd = r%2
x_off = odd * 0.5*dens
for c in range(n_cols+1):
x = x_off + dens*float(c)
n = self.add_node( np.array([x,y]) )
if c > 0:
if r==0:
self.add_edge(n-1,n,cright=-1,marker=1)
elif r==n_rows:
self.add_edge(n-1,n,cleft=-1,marker=1)
else:
self.add_edge(n,n-1)
# HERE: need to finish adding in the markers and closed boundary code.
if r>0:
cright=-2
cleft=-2
marker = 0
if odd:
if c==0:
cleft=-1
marker=1
elif c==n_cols:
cright=-1
marker=1
self.add_edge(n-(n_cols+1),n,marker=marker,cleft=cleft,cright=cright)
if c<n_cols:
self.add_edge(n,n-n_cols)
else:
if c==0:
cleft=-1
marker=1
elif c==n_cols:
cright=-1
marker=1
self.add_edge(n-(n_cols+1),n,cleft=cleft,cright=cright,marker=marker)
if c>0:
self.add_edge(n,n-(n_cols+1)-1)
class RotatedEquilateralPaver(EquilateralPaver):
""" Create a ragged-edged grid where the triangles are rotated the given
angle, in radians, CCW from parallel to the x-axis.
"""
def __init__(self,L,W,dens,angle=0,**kwargs):
self.final_L = L
self.final_W = W
# find the L and W needed to still be big enough after we've rotated -
# adding a bit of extra to avoid funny edge effects:
Lprime = L*np.cos(angle) + W*np.sin(angle) + 4*dens
Wprime = W*np.cos(angle) + L*np.sin(angle) + 4*dens
super(RotatedEquilateralPaver,self).__init__(L=Lprime, W=Wprime, dens=dens, **kwargs)
self.rotate_grid(angle)
self.trim_grid()
self.renumber()
def rotate_grid(self,angle):
""" rotates the oversized grid and translates to get the origin in the right place.
"""
# translate to get centered on the extra bit we asked for:
self.points[:] -= 2*self.dens
# rotate
self.points[:] = trigrid.rot(angle,self.points)
# and get our origin to a nice place
self.points[:,0] += self.final_L * np.sin(angle)**2
self.points[:,1] -= self.final_L * np.sin(angle)*np.cos(angle)
def trim_grid(self):
""" with the oversized grid created, and the origin correctly placed, remove points
and associated edges/cells that fall outside the actual footprint
"""
to_delete = (self.points[:,0] < 0) | (self.points[:,0]>self.final_L) | \
(self.points[:,1] < 0) | (self.points[:,1]>self.final_W)
for n in np.nonzero(to_delete)[0]:
self.delete_node(n,remove_edges=True)
if __name__ == '__main__':
#ep = EquilateralPaver(10000.,5000.,500.,orientation='horizontal')
#ep.plot()
ep = RotatedEquilateralPaver(10000.,5000.,510.,angle=15*pi/180.)
cla()
ep.plot()
|
#/usr/bin/env python3
import argparse
import glob
import json
import logging
import datetime
import os
from local import DATA_DIR, LOG_DIR, REPROCESS_DIR
def parse_files(fnames):
for fname in fnames:
stat = os.stat(fname)
f_date = str(datetime.datetime.utcfromtimestamp(stat.st_birthtime).isoformat())
data = read_file(fname)
parse_data(data, fname,f_date )
def read_file(fname):
with open(fname, 'r', encoding='utf-8') as f:
return json.load(f)
def parse_data(data, fname, f_date):
LOG_PATH = '{}/getpocket-reprocessed.log'.format(LOG_DIR)
logging.basicConfig(level=logging.INFO,
format='{"retrieved": "' + f_date +'", "level": "%(levelname)s", %(message)s}',
filename=LOG_PATH,
filemode='a+')
total = 0
resolved_id_missing = 0
for v in data['list'].values():
fn = {"filename": fname }
v.update(fn)
# Remove unnecessary data
if v.get('image'):
del v['image']
if v.get('images'):
del v['images']
if v.get('videos'):
del v['videos']
if v.get('resolved_id', 0) == 0:
resolved_id_missing += 1
logging.error('"pocket_data": {}'.format(json.dumps(v)))
# logging.error('"pocket_data": {}, "filename": {}'.format(json.dumps(v)))
continue
if v.get('authors'):
try:
author_data = v['authors'].values()
v['authors'] = [(a['name']) for a in author_data]
except BaseException:
print(v['authors'])
if v.get('tags'):
try:
tag_data = v['tags'].keys()
v['tags'] = [a for a in tag_data]
except BaseException:
print(v['tags'])
fn = {"filename": fname }
v.update(fn)
logging.info('"pocket_data": {}'.format(json.dumps(v)))
total += 1
print("Total ({}): {}".format(fname, total))
print("Missing Resolved Id ({}): {}".format(fname, resolved_id_missing))
def main():
# Get local JSON file names
file_names = glob.glob('{}/*.json'.format(REPROCESS_DIR))
# Parse all JSON files
parse_files(file_names)
main()
|
import numpy as np
from ray.rllib.models.torch.misc import SlimFC
from ray.rllib.models.torch.torch_modelv2 import TorchModelV2
from ray.rllib.utils.framework import try_import_torch, get_activation_fn
torch, nn = try_import_torch()
class DDPGTorchModel(TorchModelV2, nn.Module):
"""Extension of standard TorchModelV2 for DDPG.
Data flow:
obs -> forward() -> model_out
model_out -> get_policy_output() -> pi(s)
model_out, actions -> get_q_values() -> Q(s, a)
model_out, actions -> get_twin_q_values() -> Q_twin(s, a)
Note that this class by itself is not a valid model unless you
implement forward() in a subclass."""
def __init__(self,
obs_space,
action_space,
num_outputs,
model_config,
name,
actor_hidden_activation="relu",
actor_hiddens=(256, 256),
critic_hidden_activation="relu",
critic_hiddens=(256, 256),
twin_q=False,
add_layer_norm=False):
"""Initialize variables of this model.
Extra model kwargs:
actor_hidden_activation (str): activation for actor network
actor_hiddens (list): hidden layers sizes for actor network
critic_hidden_activation (str): activation for critic network
critic_hiddens (list): hidden layers sizes for critic network
twin_q (bool): build twin Q networks.
add_layer_norm (bool): Enable layer norm (for param noise).
Note that the core layers for forward() are not defined here, this
only defines the layers for the output heads. Those layers for
forward() should be defined in subclasses of DDPGTorchModel.
"""
nn.Module.__init__(self)
super(DDPGTorchModel, self).__init__(obs_space, action_space,
num_outputs, model_config, name)
self.bounded = np.logical_and(self.action_space.bounded_above,
self.action_space.bounded_below).any()
low_action = nn.Parameter(
torch.from_numpy(self.action_space.low).float())
low_action.requires_grad = False
self.register_parameter("low_action", low_action)
action_range = nn.Parameter(
torch.from_numpy(self.action_space.high -
self.action_space.low).float())
action_range.requires_grad = False
self.register_parameter("action_range", action_range)
self.action_dim = np.product(self.action_space.shape)
# Build the policy network.
self.policy_model = nn.Sequential()
ins = num_outputs
self.obs_ins = ins
activation = get_activation_fn(
actor_hidden_activation, framework="torch")
for i, n in enumerate(actor_hiddens):
self.policy_model.add_module(
"action_{}".format(i),
SlimFC(
ins,
n,
initializer=torch.nn.init.xavier_uniform_,
activation_fn=activation))
# Add LayerNorm after each Dense.
if add_layer_norm:
self.policy_model.add_module("LayerNorm_A_{}".format(i),
nn.LayerNorm(n))
ins = n
self.policy_model.add_module(
"action_out",
SlimFC(
ins,
self.action_dim,
initializer=torch.nn.init.xavier_uniform_,
activation_fn=None))
# Use sigmoid to scale to [0,1], but also double magnitude of input to
# emulate behaviour of tanh activation used in DDPG and TD3 papers.
# After sigmoid squashing, re-scale to env action space bounds.
class _Lambda(nn.Module):
def forward(self_, x):
sigmoid_out = nn.Sigmoid()(2.0 * x)
squashed = self.action_range * sigmoid_out + self.low_action
return squashed
# Only squash if we have bounded actions.
if self.bounded:
self.policy_model.add_module("action_out_squashed", _Lambda())
# Build the Q-net(s), including target Q-net(s).
def build_q_net(name_):
activation = get_activation_fn(
critic_hidden_activation, framework="torch")
# For continuous actions: Feed obs and actions (concatenated)
# through the NN. For discrete actions, only obs.
q_net = nn.Sequential()
ins = self.obs_ins + self.action_dim
for i, n in enumerate(critic_hiddens):
q_net.add_module(
"{}_hidden_{}".format(name_, i),
SlimFC(
ins,
n,
initializer=torch.nn.init.xavier_uniform_,
activation_fn=activation))
ins = n
q_net.add_module(
"{}_out".format(name_),
SlimFC(
ins,
1,
initializer=torch.nn.init.xavier_uniform_,
activation_fn=None))
return q_net
self.q_model = build_q_net("q")
if twin_q:
self.twin_q_model = build_q_net("twin_q")
else:
self.twin_q_model = None
def get_q_values(self, model_out, actions):
"""Return the Q estimates for the most recent forward pass.
This implements Q(s, a).
Args:
model_out (Tensor): obs embeddings from the model layers, of shape
[BATCH_SIZE, num_outputs].
actions (Tensor): Actions to return the Q-values for.
Shape: [BATCH_SIZE, action_dim].
Returns:
tensor of shape [BATCH_SIZE].
"""
return self.q_model(torch.cat([model_out, actions], -1))
def get_twin_q_values(self, model_out, actions):
"""Same as get_q_values but using the twin Q net.
This implements the twin Q(s, a).
Args:
model_out (Tensor): obs embeddings from the model layers, of shape
[BATCH_SIZE, num_outputs].
actions (Optional[Tensor]): Actions to return the Q-values for.
Shape: [BATCH_SIZE, action_dim].
Returns:
tensor of shape [BATCH_SIZE].
"""
return self.twin_q_model(torch.cat([model_out, actions], -1))
def get_policy_output(self, model_out):
"""Return the action output for the most recent forward pass.
This outputs the support for pi(s). For continuous action spaces, this
is the action directly. For discrete, is is the mean / std dev.
Args:
model_out (Tensor): obs embeddings from the model layers, of shape
[BATCH_SIZE, num_outputs].
Returns:
tensor of shape [BATCH_SIZE, action_out_size]
"""
return self.policy_model(model_out)
def policy_variables(self, as_dict=False):
"""Return the list of variables for the policy net."""
if as_dict:
return self.policy_model.state_dict()
return list(self.policy_model.parameters())
def q_variables(self, as_dict=False):
"""Return the list of variables for Q / twin Q nets."""
if as_dict:
return {
**self.q_model.state_dict(),
**(self.twin_q_model.state_dict() if self.twin_q_model else {})
}
return list(self.q_model.parameters()) + \
(list(self.twin_q_model.parameters()) if self.twin_q_model else [])
|
#!/usr/bin/python3.5
import os
import shutil
import subprocess
from common.serializers.compact_serializer import CompactSerializer
from common.serializers.json_serializer import JsonSerializer
from common.serializers.mapping_serializer import MappingSerializer
from ledger.compact_merkle_tree import CompactMerkleTree
from ledger.ledger import Ledger
from plenum.persistence.leveldb_hash_store import LevelDbHashStore
from storage import store_utils
from storage.chunked_file_store import ChunkedFileStore
from indy_common.config_util import getConfig
from indy_common.txn_util import getTxnOrderedFields
from stp_core.common.log import getlogger
config = getConfig()
logger = getlogger()
def __migrate_ledger(data_directory,
old_ledger_file, new_ledger_file,
serializer: MappingSerializer = None):
"""
Test for the directory, open old and new ledger, migrate data, rename directories
"""
# we should have ChunkedFileStorage implementation of the Ledger
if not os.path.isdir(os.path.join(data_directory, old_ledger_file)):
msg = 'Could not find directory {} for migration.'.format(
old_ledger_file)
logger.error(msg)
raise Exception(msg)
# open the old ledger using the specified serializer
old_ledger_file_backup = old_ledger_file + "_new"
old_txn_log_store = ChunkedFileStore(data_directory,
old_ledger_file_backup,
isLineNoKey=True,
storeContentHash=False)
old_ledger = Ledger(CompactMerkleTree(),
dataDir=data_directory,
txn_serializer=serializer,
hash_serializer=serializer,
fileName=old_ledger_file_backup,
transactionLogStore=old_txn_log_store)
# open the new ledger with new serialization
new_ledger = Ledger(CompactMerkleTree(),
dataDir=data_directory,
fileName=new_ledger_file)
logger.info("new size for {}: {}".format(
old_ledger_file_backup, str(new_ledger.size)))
# add all txns into the old ledger
for _, txn in new_ledger.getAllTxn():
old_ledger.add(txn)
logger.info("old size for {}: {}".format(
new_ledger_file, str(old_ledger.size)))
old_ledger.stop()
new_ledger.stop()
# now that everything succeeded, remove the new files and move the old
# files into place
shutil.rmtree(
os.path.join(data_directory, new_ledger_file))
os.rename(
os.path.join(data_directory, old_ledger_file_backup),
os.path.join(data_directory, old_ledger_file))
def __open_old_ledger(data_directory, old_ledger_file,
hash_store_name, serializer):
# open old Ledger with leveldb hash store (to re-init it)
old_txn_log_store = ChunkedFileStore(data_directory,
old_ledger_file,
isLineNoKey=True,
storeContentHash=False)
old_ledger = Ledger(CompactMerkleTree(
hashStore=LevelDbHashStore(
dataDir=data_directory,
fileNamePrefix=hash_store_name)),
dataDir=data_directory,
txn_serializer=serializer,
hash_serializer=serializer,
fileName=old_ledger_file,
transactionLogStore=old_txn_log_store)
old_ledger.stop()
def migrate_all_hash_stores(node_data_directory):
# the new hash store (merkle tree) will be recovered from the new transaction log after re-start
# just delete the current hash store
new_merkle_nodes = os.path.join(node_data_directory, '_merkleNodes')
new_merkle_leaves = os.path.join(node_data_directory, '_merkleLeaves')
new_merkle_nodes_bin = os.path.join(
node_data_directory, '_merkleNodes.bin')
new_merkle_leaves_bin = os.path.join(
node_data_directory, '_merkleLeaves.bin')
new_merkle_nodes_config_bin = os.path.join(
node_data_directory, 'config_merkleNodes.bin')
new_merkle_leaves_config_bin = os.path.join(
node_data_directory, 'config_merkleLeaves.bin')
if os.path.exists(new_merkle_nodes):
shutil.rmtree(new_merkle_nodes)
if os.path.exists(new_merkle_leaves):
shutil.rmtree(new_merkle_leaves)
if os.path.exists(new_merkle_nodes_bin):
os.remove(new_merkle_nodes_bin)
if os.path.exists(new_merkle_leaves_bin):
os.remove(new_merkle_leaves_bin)
if os.path.exists(new_merkle_nodes_config_bin):
os.remove(new_merkle_nodes_config_bin)
if os.path.exists(new_merkle_leaves_config_bin):
os.remove(new_merkle_leaves_config_bin)
# open new Ledgers
fields = getTxnOrderedFields()
__open_old_ledger(node_data_directory, config.poolTransactionsFile,
'pool', serializer=JsonSerializer())
__open_old_ledger(node_data_directory, config.domainTransactionsFile,
'domain', serializer=CompactSerializer(fields=fields))
__open_old_ledger(node_data_directory, config.configTransactionsFile,
'config', serializer=JsonSerializer())
def migrate_all_ledgers_for_node(node_data_directory):
# using default ledger names
__migrate_ledger(node_data_directory,
config.poolTransactionsFile, config.poolTransactionsFile,
serializer=JsonSerializer())
__migrate_ledger(
node_data_directory,
config.configTransactionsFile,
config.configTransactionsFile,
serializer=JsonSerializer())
# domain ledger uses custom CompactSerializer and old file name
fields = getTxnOrderedFields()
__migrate_ledger(node_data_directory,
config.domainTransactionsFile.replace(
'domain_', ''), config.domainTransactionsFile,
serializer=CompactSerializer(fields=fields))
def migrate_all_states(node_data_directory):
# the states will be recovered from the ledger during the start-up.
# just delete the current ones
shutil.rmtree(
os.path.join(node_data_directory, 'pool_state'))
shutil.rmtree(
os.path.join(node_data_directory, 'domain_state'))
shutil.rmtree(
os.path.join(node_data_directory, 'config_state'))
def migrate_genesis_txn(base_dir):
for suffix in ('sandbox', 'live', 'local'):
old_domain_genesis = os.path.join(
base_dir, 'transactions_{}'.format(suffix))
old_pool_genesis = os.path.join(
base_dir, 'pool_transactions_{}'.format(suffix))
new_domain_genesis = os.path.join(
base_dir, 'domain_transactions_{}_genesis'.format(suffix))
new_pool_genesis = os.path.join(
base_dir, 'pool_transactions_{}_genesis'.format(suffix))
if os.path.exists(old_domain_genesis):
os.remove(old_domain_genesis)
if os.path.exists(old_pool_genesis):
os.remove(old_pool_genesis)
if os.path.exists(new_domain_genesis):
old_ser = CompactSerializer(getTxnOrderedFields())
new_ser = JsonSerializer()
with open(new_domain_genesis, 'r') as f1:
with open(old_domain_genesis, 'w') as f2:
for line in store_utils.cleanLines(f1):
txn = new_ser.deserialize(line)
txn = old_ser.serialize(txn)
f2.write(txn)
os.remove(new_domain_genesis)
if os.path.exists(new_pool_genesis):
os.rename(new_pool_genesis, old_domain_genesis)
def migrate_all():
base_dir = config.baseDir
nodes_data_dir = os.path.join(base_dir, config.nodeDataDir)
if not os.path.exists(nodes_data_dir):
# TODO: find a better way
base_dir = '/home/sovrin/.sovrin'
nodes_data_dir = os.path.join(base_dir, config.nodeDataDir)
if not os.path.exists(nodes_data_dir):
msg = 'Can not find the directory with the ledger: {}'.format(
nodes_data_dir)
logger.error(msg)
raise Exception(msg)
for node_dir in os.listdir(nodes_data_dir):
node_data_dir = os.path.join(nodes_data_dir, node_dir)
migrate_all_ledgers_for_node(node_data_dir)
migrate_all_hash_stores(node_data_dir)
migrate_all_states(node_data_dir)
migrate_genesis_txn(base_dir)
subprocess.run(['chown', '-R', 'sovrin:sovrin', '/home/sovrin/.sovrin'])
migrate_all()
|
"""
The MIT License (MIT)
Copyright (c) 2016 mhan-team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
from django.contrib import admin
from .models import Trace, Point
# Register your models here.
admin.site.register(Trace)
admin.site.register(Point)
|
import create
import time
import io
import os
import sys
import argparse
# define silence
r = 30
# map note names in the lilypad notation to irobot commands
c4 = 60
cis4 = des4 = 61
d4 = 62
dis4 = ees4 = 63
e4 = 64
f4 = 65
fis4 = ges4 = 66
g4 = 67
gis4 = aes4 = 68
a4 = 69
ais4 = bes4 = 70
b4 = 71
c5 = 72
cis5 = des5 = 73
d5 = 74
dis5 = ees5 = 75
e5 = 76
f5 = 77
fis5 = ges5 = 78
g5 = 79
gis5 = aes5 = 80
a5 = 81
ais5 = bes5 = 82
b5 = 83
c6 = 84
cis6 = des6 = 85
d6 = 86
dis6 = ees6 = 87
e6 = 88
f6 = 89
fis6 = ges6 = 90
# define some note lengths
# change the top MEASURE (4/4 time) to get faster/slower speeds
MEASURE = 160
HALF = MEASURE/2
Q = MEASURE/4
E = MEASURE/8
Ed = MEASURE*3/16
S = MEASURE/16
MEASURE_TIME = MEASURE/64.
ROOMBA_PORT = "/dev/rfcomm0"
FIFO_PATH = "/tmp/roombaCommands"
#parser
parser = argparse.ArgumentParser(description="Roomba Voice Command Control Software")
parser.add_argument("-k", dest="keyword", help="Keyword for addressing the roomba", default="")
parser.add_argument("-p", dest="path", help="path where creating the FIFO", default=FIFO_PATH)
parser.add_argument("-r", dest="roomba", help="serial port to the roomba", default=ROOMBA_PORT)
#parsing args
args = parser.parse_args()
keyword = args.keyword.lower()
print("keyword is " + keyword)
FIFO_PATH = args.path
print("created fifo in "+ FIFO_PATH)
ROOMBA_PORT = args.roomba
print("roomba port set to "+ ROOMBA_PORT)
#telekom jingle
telekom = [(c4,S), (c4,S), (c4,S), (e4,S), (c4,Q)]
#fifo init
try:
os.mkfifo(FIFO_PATH, 0766)
except:
os.unlink(FIFO_PATH)
os.mkfifo(FIFO_PATH, 0766)
#robot init
robot = create.Create(ROOMBA_PORT, create.SAFE_MODE)
robot.setSong(1, telekom)
def clean_up():
print("clean up and exit")
os.unlink(FIFO_PATH)
robot.close()
sys.exit(0)
def main():
exit_loop = False
fifo = open(FIFO_PATH, "r")
while exit_loop == False:
line = fifo.readline()
if line != "":
#line = keyword_ignore.sub("", line).strip(" ").strip("\n")
line = line.lower().replace(keyword, "").strip(" ").strip("\n")
print(line)
if line == "clean":
robot.toSafeMode()
time.sleep(.5)
print("starting to clean")
robot._write(create.CLEAN)
if line == "spot":
robot.toSafeMode()
time.sleep(.5)
print("starting to spot clean")
robot._write(create.SPOT)
if line == "stop":
print("stopping")
robot.toSafeMode()
time.sleep(.5)
if line == "dock":
robot.toSafeMode()
time.sleep(.5)
print("seeking dock")
robot._write(create.FORCESEEKINGDOCK)
if line == "jingle":
robot.toSafeMode()
time.sleep(.5)
robot.playSongNumber(1)
if line == "close":
exit_loop = True
try:
main()
except:
print("\nexception -> ")
clean_up()
|
#!/usr/local/bin/python
import unittest
import sys
import os.path
import glob
import ConfigParser
from pdftools.PdfSeparate import *
from abbyy.AbbyyPdfTextExtractor import *
from urllib2 import HTTPError
class AbbyyPdfTextExtractorNetworkTest(unittest.TestCase):
def setUp(self):
self.outdir = "tests/out/abbyy/text"
self.indir = "tests/out/abbyy/pdf"
self.createOrCleanDir(self.outdir)
self.createOrCleanDir(self.indir)
self.configParser = ConfigParser.RawConfigParser()
self.configParser.read('settings.config')
def createOrCleanDir(self, directory):
if not os.path.exists(directory):
os.makedirs(directory)
else:
files = glob.glob(directory)
for f in files:
if os.path.isfile(f):
os.remove(f)
def testScanned44PdfPageForNetwork(self):
pdfSeparate = PdfSeparate('tests/sample-scanned-44pages.pdf', self.indir)
pdfSeparate.extractPages()
self.assertTrue(os.path.isfile(os.path.join(self.indir,"1.pdf")))
try:
abbyyPdf = AbbyyPdfTextExtractor(self.indir, self.outdir, 44, "english")
abbyyPdf.setApplicationCredentials(self.configParser.get('abbyy','appid'), self.configParser.get('abbyy','password'))
abbyyPdf.extractPages();
self.assertTrue(os.path.isfile(os.path.join(self.outdir,"1.txt")))
self.assertTrue(os.path.isfile(os.path.join(self.outdir,"44.txt")))
except Exception:
pass
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
This file tests the TauP_Time utility against the original TauPy using
both the high-level tau interface of TauPy and the java-like old script-based
interface.
"""
from __future__ import (absolute_import, division, print_function,
unicode_literals)
from future.builtins import *
import inspect
import os
import unittest
import sys
import subprocess
from taupy.tau import TauPyModel
from taupy.TauP_Time import TauP_Time
# Most generic way to get the data folder path.
DATA = os.path.join(os.path.dirname(os.path.abspath(
inspect.getfile(inspect.currentframe()))), "data", "TauP_test_data")
def parse_taup_time_output(filename):
with open(filename, "rt") as fh:
data_started = False
arrivals = []
for line in fh:
line = line.strip()
if not line:
continue
if line.startswith("-------"):
data_started = True
continue
if data_started is False:
continue
l = [_i.strip() for _i in line.split() if _i != "="]
arrivals.append({
"distance": float(l[0]),
"depth": float(l[1]),
"phase_name": str(l[2]),
"time": float(l[3]),
"ray_param": float(l[4]),
"takeoff": float(l[5]),
"incident": float(l[6]),
"purist_distance": float(l[7]),
"purist_name": str(l[8]),
})
return arrivals
def compare_arrivals_with_taup_time_output(arrivals, filename):
filename = os.path.join(DATA, filename)
expected_arrivals = parse_taup_time_output(filename)
arrivals = [
{
"distance": _i.getModuloDistDeg(),
"depth": _i.sourceDepth,
"phase_name": _i.phase.name,
"time": _i.time,
"ray_param": _i.rayParam_sec_degree,
"takeoff": _i.takeoffAngle,
"incident": _i.incidentAngle,
"purist_distance": _i.getDistDeg(),
"purist_name": _i.puristName
} for _i in arrivals]
# Sort both by time.
expected_arrivals = sorted(expected_arrivals, key=lambda x: x["time"])
arrivals = sorted(arrivals, key=lambda x: x["time"])
assert len(expected_arrivals) == len(arrivals)
for e_arr, arr in zip(expected_arrivals, arrivals):
assert sorted(e_arr.keys()) == sorted(arr.keys())
for key, value in e_arr.items():
if isinstance(value, float):
# Estimate the precision in the taup output.
v = str(value)
prec = len(v) - v.find(".") - 1
assert value == round(arr[key], prec)
else:
assert value == arr[key]
def test_all_phases_iasp91_35_deg_distance():
"""
Tests tauptime at 35 degree distance, phases ttall.
"""
model = TauPyModel("iasp91")
tts = model.get_travel_times(source_depth_in_km=10.0,
distance_in_degree=35.0)
compare_arrivals_with_taup_time_output(
tts, "taup_time_-h_10_-ph_ttall_-deg_35")
class TestTauPTime(unittest.TestCase):
# For some reason this test throws nosetests off if not in the unittest
# framwork like the test above...?
def test_all_phases_ak135_35_deg_distance(self):
"""
Tests tauptime at 35 degree distance for the ak135 model, phases ttall.
"""
model = TauPyModel("ak135")
tts = model.get_travel_times(source_depth_in_km=10.0,
distance_in_degree=35.0)
compare_arrivals_with_taup_time_output(
tts, "taup_time_-h_10_-ph_ttall_-deg_35_-mod_ak135")
def test_range(self):
"""
Check taup_time output for a range of inputs against the Java output.
"""
if not os.path.isfile("data/java_tauptime_testoutput"):
subprocess.call("./generate_tauptime_output.sh", shell=True)
stdout = sys.stdout
with open('data/taup_time_test_output', 'wt') as sys.stdout:
for degree in [0, 45, 90, 180, 360, 560]:
for depth in [0, 100, 1000, 2889]:
tauptime = TauP_Time(degrees=degree, depth=depth,
modelName="iasp91",
phaseList=["ttall"])
tauptime.run(printOutput=True)
sys.stdout = stdout
# Using ttall need to sort; or lines with same arrival times are in
# different order. With explicit names of all the phases might not be
# a problem.
subprocess.check_call("./compare_tauptime_outputs.sh", shell=True)
# Use this if lines are in same order:
#subprocess.check_call("diff -wB data/java_tauptime_testoutput "
# "taup_time_test_output", shell=True)
os.remove("data/taup_time_test_output")
def test_degree_distance_from_coords(self):
"""
Test the calculation of spherical distance from given coordinates.
"""
tt = TauP_Time(depth=143.2, phaseList=["ttall"],
coordinate_list=[13, 14, 50, 200])
tt.run()
self.assertEqual(tt.degrees, 116.77958601543997)
def test_MCM_model(self):
"""
Test Taup_Time for the MCM_MPS05_XPYQ_C1D2L_S09-M2.tvel model.
"""
mcm = TauPyModel("MCM_MPS05_XPYQ_C1D2L_S09-M2.tvel")
times = mcm.get_travel_times(300, 180)
compare_arrivals_with_taup_time_output(times,
"taup_time_MCM_testfile")
if __name__ == '__main__':
unittest.main(buffer=True)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright 2010-2013 Zuza Software Foundation
#
# This file is part of Pootle.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
import os
import logging
from itertools import groupby
from django.conf import settings
from django.contrib.auth.models import User
from django.core.cache import cache
from django.core.exceptions import PermissionDenied, ObjectDoesNotExist
from django.db.models import Q
from django.http import HttpResponse, Http404
from django.shortcuts import get_object_or_404, render_to_response
from django.template import loader, RequestContext
from django.utils.translation import to_locale, ugettext as _
from django.utils.translation.trans_real import parse_accept_lang_header
from django.utils import simplejson, timezone
from django.utils.encoding import iri_to_uri
from django.views.decorators.cache import never_cache
from translate.lang import data
from pootle.core.decorators import (get_translation_project,
set_request_context)
from pootle_app.models import Suggestion as SuggestionStat
from pootle_app.models.permissions import (get_matching_permissions,
check_permission,
check_profile_permission)
from pootle_misc.baseurl import redirect
from pootle_misc.checks import check_names, get_quality_check_failures
from pootle_misc.forms import make_search_form
from pootle_misc.stats import get_raw_stats
from pootle_misc.url_manip import ensure_uri, previous_view_url
from pootle_misc.util import paginate, ajax_required, jsonify
from pootle_profile.models import get_profile
from pootle_statistics.models import (Submission, SubmissionFields,
SubmissionTypes)
from .decorators import get_store_context, get_unit_context
from .models import Store, Unit
from .forms import (unit_comment_form_factory, unit_form_factory,
highlight_whitespace)
from .signals import translation_submitted
from .templatetags.store_tags import (highlight_diffs, pluralize_source,
pluralize_target)
from .util import (UNTRANSLATED, FUZZY, TRANSLATED, STATES_MAP,
absolute_real_path, find_altsrcs, get_sugg_list)
@get_store_context('view')
def export_as_xliff(request, store):
"""Export given file to xliff for offline translation."""
path = store.real_path
if not path:
# bug 2106
project = request.translation_project.project
if project.get_treestyle() == "gnu":
path = "/".join(store.pootle_path.split(os.path.sep)[2:])
else:
parts = store.pootle_path.split(os.path.sep)[1:]
path = "%s/%s/%s" % (parts[1], parts[0], "/".join(parts[2:]))
path, ext = os.path.splitext(path)
export_path = "/".join(['POOTLE_EXPORT', path + os.path.extsep + 'xlf'])
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_xliff" % store.pootle_path)
last_export = cache.get(key)
if (not (last_export and last_export == store.get_mtime() and
os.path.isfile(abs_export_path))):
from pootle_app.project_tree import ensure_target_dir_exists
from translate.storage.poxliff import PoXliffFile
from pootle_misc import ptempfile as tempfile
import shutil
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(PoXliffFile)
outputstore.switchfile(store.name, createifmissing=True)
fd, tempstore = tempfile.mkstemp(prefix=store.name, suffix='.xlf')
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
@get_store_context('view')
def export_as_type(request, store, filetype):
"""Export given file to xliff for offline translation."""
from pootle_store.filetypes import factory_classes, is_monolingual
klass = factory_classes.get(filetype, None)
if (not klass or is_monolingual(klass) or
store.pootle_path.endswith(filetype)):
raise ValueError
path, ext = os.path.splitext(store.real_path)
export_path = os.path.join('POOTLE_EXPORT',
path + os.path.extsep + filetype)
abs_export_path = absolute_real_path(export_path)
key = iri_to_uri("%s:export_as_%s" % (store.pootle_path, filetype))
last_export = cache.get(key)
if (not (last_export and last_export == store.get_mtime() and
os.path.isfile(abs_export_path))):
from pootle_app.project_tree import ensure_target_dir_exists
from pootle_misc import ptempfile as tempfile
import shutil
ensure_target_dir_exists(abs_export_path)
outputstore = store.convert(klass)
fd, tempstore = tempfile.mkstemp(prefix=store.name,
suffix=os.path.extsep + filetype)
os.close(fd)
outputstore.savefile(tempstore)
shutil.move(tempstore, abs_export_path)
cache.set(key, store.get_mtime(), settings.OBJECT_CACHE_TIMEOUT)
return redirect('/export/' + export_path)
@get_store_context('view')
def download(request, store):
store.sync(update_translation=True)
return redirect('/export/' + store.real_path)
def get_filter_name(GET):
"""Gets current filter's human-readable name.
:param GET: A copy of ``request.GET``.
:return: Two-tuple with the filter name, and a list of extra arguments
passed to the current filter.
"""
filter = extra = None
if 'filter' in GET:
filter = GET['filter']
if filter.startswith('user-'):
extra = [GET.get('user', _('User missing'))]
elif filter == 'checks' and 'checks' in GET:
extra = map(lambda check: check_names.get(check, check),
GET['checks'].split(','))
elif 'search' in GET:
filter = 'search'
extra = [GET['search']]
if 'sfields' in GET:
extra.extend(GET['sfields'].split(','))
filter_name = {
'all': _('All'),
'translated': _('Translated'),
'untranslated': _('Untranslated'),
'fuzzy': _('Needs work'),
'incomplete': _('Incomplete'),
# Translators: This is the name of a filter
'search': _('Search'),
'checks': _('Checks'),
'user-submissions': _('Submissions'),
'user-submissions-overwritten': _('Overwritten submissions'),
}.get(filter)
return (filter_name, extra)
@get_translation_project
@set_request_context
def export_view(request, translation_project, dir_path, filename=None):
"""Displays a list of units with filters applied."""
current_path = translation_project.directory.pootle_path + dir_path
if filename:
current_path = current_path + filename
store = get_object_or_404(Store, pootle_path=current_path)
units_qs = store.units
else:
store = None
units_qs = translation_project.units.filter(
store__pootle_path__startswith=current_path,
)
filter_name, filter_extra = get_filter_name(request.GET)
units = get_step_query(request, units_qs)
unit_groups = [(path, list(units)) for path, units in
groupby(units, lambda x: x.store.path)]
ctx = {
'source_language': translation_project.project.source_language,
'language': translation_project.language,
'project': translation_project.project,
'unit_groups': unit_groups,
'filter_name': filter_name,
'filter_extra': filter_extra,
}
return render_to_response('store/list.html', ctx,
context_instance=RequestContext(request))
####################### Translate Page ##############################
def get_alt_src_langs(request, profile, translation_project):
language = translation_project.language
project = translation_project.project
source_language = project.source_language
langs = profile.alt_src_langs.exclude(
id__in=(language.id, source_language.id)
).filter(translationproject__project=project)
if not profile.alt_src_langs.count():
from pootle_language.models import Language
accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
for accept_lang, unused in parse_accept_lang_header(accept):
if accept_lang == '*':
continue
simplified = data.simplify_to_common(accept_lang)
normalized = to_locale(data.normalize_code(simplified))
code = to_locale(accept_lang)
if (normalized in
('en', 'en_US', source_language.code, language.code) or
code in ('en', 'en_US', source_language.code, language.code)):
continue
langs = Language.objects.filter(
code__in=(normalized, code),
translationproject__project=project,
)
if langs.count():
break
return langs
def get_non_indexed_search_step_query(form, units_queryset):
words = form.cleaned_data['search'].split()
result = units_queryset.none()
if 'source' in form.cleaned_data['sfields']:
subresult = units_queryset
for word in words:
subresult = subresult.filter(source_f__icontains=word)
result = result | subresult
if 'target' in form.cleaned_data['sfields']:
subresult = units_queryset
for word in words:
subresult = subresult.filter(target_f__icontains=word)
result = result | subresult
if 'notes' in form.cleaned_data['sfields']:
translator_subresult = units_queryset
developer_subresult = units_queryset
for word in words:
translator_subresult = translator_subresult.filter(
translator_comment__icontains=word,
)
developer_subresult = developer_subresult.filter(
developer_comment__icontains=word,
)
result = result | translator_subresult | developer_subresult
if 'locations' in form.cleaned_data['sfields']:
subresult = units_queryset
for word in words:
subresult = subresult.filter(locations__icontains=word)
result = result | subresult
return result
def get_search_step_query(translation_project, form, units_queryset):
"""Narrows down units query to units matching search string."""
if translation_project.indexer is None:
logging.debug(u"No indexer for %s, using database search",
translation_project)
return get_non_indexed_search_step_query(form, units_queryset)
logging.debug(u"Found %s indexer for %s, using indexed search",
translation_project.indexer.INDEX_DIRECTORY_NAME,
translation_project)
word_querylist = []
words = form.cleaned_data['search'].split()
fields = form.cleaned_data['sfields']
paths = units_queryset.order_by() \
.values_list('store__pootle_path', flat=True) \
.distinct()
path_querylist = [('pofilename', pootle_path)
for pootle_path in paths.iterator()]
cache_key = "search:%s" % str(hash((repr(path_querylist),
translation_project.get_mtime(),
repr(words),
repr(fields))))
dbids = cache.get(cache_key)
if dbids is None:
searchparts = []
# Split the search expression into single words. Otherwise Xapian and
# Lucene would interpret the whole string as an "OR" combination of
# words instead of the desired "AND".
for word in words:
# Generate a list for the query based on the selected fields
word_querylist = [(field, word) for field in fields]
textquery = translation_project.indexer.make_query(word_querylist,
False)
searchparts.append(textquery)
pathquery = translation_project.indexer.make_query(path_querylist,
False)
searchparts.append(pathquery)
limitedquery = translation_project.indexer.make_query(searchparts, True)
result = translation_project.indexer.search(limitedquery, ['dbid'])
dbids = [int(item['dbid'][0]) for item in result[:999]]
cache.set(cache_key, dbids, settings.OBJECT_CACHE_TIMEOUT)
return units_queryset.filter(id__in=dbids)
def get_step_query(request, units_queryset):
"""Narrows down unit query to units matching conditions in GET."""
if 'filter' in request.GET:
unit_filter = request.GET['filter']
username = request.GET.get('user', None)
profile = request.profile
if username:
try:
user = User.objects.get(username=username)
profile = user.get_profile()
except User.DoesNotExist:
pass
if unit_filter:
match_queryset = units_queryset.none()
if unit_filter == 'all':
match_queryset = units_queryset
elif unit_filter == 'translated':
match_queryset = units_queryset.filter(state=TRANSLATED)
elif unit_filter == 'untranslated':
match_queryset = units_queryset.filter(state=UNTRANSLATED)
elif unit_filter == 'fuzzy':
match_queryset = units_queryset.filter(state=FUZZY)
elif unit_filter == 'incomplete':
match_queryset = units_queryset.filter(
Q(state=UNTRANSLATED) | Q(state=FUZZY),
)
elif unit_filter == 'suggestions':
#FIXME: is None the most efficient query
match_queryset = units_queryset.exclude(suggestion=None)
elif unit_filter == 'user-suggestions':
match_queryset = units_queryset.filter(
suggestion__user=profile,
).distinct()
elif unit_filter == 'user-suggestions-accepted':
# FIXME: Oh, this is pretty lame, we need a completely
# different way to model suggestions
unit_ids = SuggestionStat.objects.filter(
suggester=profile,
state='accepted',
).values_list('unit', flat=True)
match_queryset = units_queryset.filter(
id__in=unit_ids,
).distinct()
elif unit_filter == 'user-suggestions-rejected':
# FIXME: Oh, this is as lame as above
unit_ids = SuggestionStat.objects.filter(
suggester=profile,
state='rejected',
).values_list('unit', flat=True)
match_queryset = units_queryset.filter(
id__in=unit_ids,
).distinct()
elif unit_filter == 'user-submissions':
match_queryset = units_queryset.filter(
submission__submitter=profile,
).distinct()
elif unit_filter == 'user-submissions-overwritten':
match_queryset = units_queryset.filter(
submission__submitter=profile,
).exclude(submitted_by=profile).distinct()
elif unit_filter == 'checks' and 'checks' in request.GET:
checks = request.GET['checks'].split(',')
if checks:
match_queryset = units_queryset.filter(
qualitycheck__false_positive=False,
qualitycheck__name__in=checks
).distinct()
units_queryset = match_queryset
if 'search' in request.GET and 'sfields' in request.GET:
# use the search form for validation only
search_form = make_search_form(request.GET)
if search_form.is_valid():
units_queryset = get_search_step_query(request.translation_project,
search_form, units_queryset)
return units_queryset
def translate_page(request):
cantranslate = check_permission("translate", request)
cansuggest = check_permission("suggest", request)
canreview = check_permission("review", request)
translation_project = request.translation_project
language = translation_project.language
project = translation_project.project
profile = request.profile
store = getattr(request, "store", None)
directory = getattr(request, "directory", None)
is_single_file = store and True or False
path = is_single_file and store.path or directory.path
pootle_path = (is_single_file and store.pootle_path or
directory.pootle_path)
is_terminology = (project.is_terminology or store and
store.is_terminology)
search_form = make_search_form(request=request,
terminology=is_terminology)
previous_overview_url = previous_view_url(request, ['overview'])
context = {
'cantranslate': cantranslate,
'cansuggest': cansuggest,
'canreview': canreview,
'search_form': search_form,
'store': store,
'store_id': store and store.id,
'directory': directory,
'directory_id': directory and directory.id,
'path': path,
'pootle_path': pootle_path,
'is_single_file': is_single_file,
'language': language,
'project': project,
'translation_project': translation_project,
'profile': profile,
'source_language': translation_project.project.source_language,
'previous_overview_url': previous_overview_url,
'MT_BACKENDS': settings.MT_BACKENDS,
'LOOKUP_BACKENDS': settings.LOOKUP_BACKENDS,
'AMAGAMA_URL': settings.AMAGAMA_URL,
}
return render_to_response('store/translate.html', context,
context_instance=RequestContext(request))
@get_store_context('view')
def translate(request, store):
return translate_page(request)
#
# Views used with XMLHttpRequest requests.
#
def _filter_ctx_units(units_qs, unit, how_many, gap=0):
"""Returns ``how_many``*2 units that are before and after ``index``."""
result = {'before': [], 'after': []}
if how_many and unit.index - gap > 0:
before = units_qs.filter(store=unit.store_id, index__lt=unit.index) \
.order_by('-index')[gap:how_many+gap]
result['before'] = _build_units_list(before, reverse=True)
result['before'].reverse()
#FIXME: can we avoid this query if length is known?
if how_many:
after = units_qs.filter(store=unit.store_id,
index__gt=unit.index)[gap:how_many+gap]
result['after'] = _build_units_list(after)
return result
def _build_units_list(units, reverse=False):
"""Given a list/queryset of units, builds a list with the unit data
contained in a dictionary ready to be returned as JSON.
:return: A list with unit id, source, and target texts. In case of
having plural forms, a title for the plural form is also provided.
"""
return_units = []
for unit in iter(units):
source_unit = []
target_unit = []
for i, source, title in pluralize_source(unit):
unit_dict = {'text': source}
if title:
unit_dict["title"] = title
source_unit.append(unit_dict)
for i, target, title in pluralize_target(unit):
unit_dict = {'text': target}
if title:
unit_dict["title"] = title
target_unit.append(unit_dict)
prev = None
next = None
if return_units:
if reverse:
return_units[-1]['prev'] = unit.id
next = return_units[-1]['id']
else:
return_units[-1]['next'] = unit.id
prev = return_units[-1]['id']
return_units.append({'id': unit.id,
'isfuzzy': unit.isfuzzy(),
'prev': prev,
'next': next,
'source': source_unit,
'target': target_unit})
return return_units
def _build_pager_dict(pager):
"""Given a pager object ``pager``, retrieves all the information needed
to build a pager.
:return: A dictionary containing necessary pager information to build
a pager.
"""
return {"number": pager.number,
"num_pages": pager.paginator.num_pages,
"per_page": pager.paginator.per_page
}
def _get_index_in_qs(qs, unit, store=False):
"""Given a queryset ``qs``, returns the position (index) of the unit
``unit`` within that queryset. ``store`` specifies if the queryset is
limited to a single store.
:return: Value representing the position of the unit ``unit``.
:rtype: int
"""
if store:
return qs.filter(index__lt=unit.index).count()
else:
store = unit.store
return (qs.filter(store=store, index__lt=unit.index) | \
qs.filter(store__pootle_path__lt=store.pootle_path)).count()
def get_view_units(request, units_queryset, store, limit=0):
"""Gets source and target texts excluding the editing unit.
:return: An object in JSON notation that contains the source and target
texts for units that will be displayed before and after editing
unit.
If asked by using the ``meta`` and ``pager`` parameters,
metadata and pager information will be calculated and returned
too.
"""
current_unit = None
json = {}
try:
limit = int(limit)
except ValueError:
limit = None
if not limit:
limit = request.profile.get_unit_rows()
step_queryset = get_step_query(request, units_queryset)
# Return metadata it has been explicitely requested
if request.GET.get('meta', False):
tp = request.translation_project
json["meta"] = {"source_lang": tp.project.source_language.code,
"source_dir": tp.project.source_language.get_direction(),
"target_lang": tp.language.code,
"target_dir": tp.language.get_direction(),
"project_style": tp.project.checkstyle}
# Maybe we are trying to load directly a specific unit, so we have
# to calculate its page number
uid = request.GET.get('uid', None)
if uid:
current_unit = units_queryset.get(id=uid)
preceding = _get_index_in_qs(step_queryset, current_unit, store)
page = preceding / limit + 1
else:
page = None
pager = paginate(request, step_queryset, items=limit, page=page)
json["units"] = _build_units_list(pager.object_list)
# Return paging information if requested to do so
if request.GET.get('pager', False):
json["pager"] = _build_pager_dict(pager)
if not current_unit:
try:
json["uid"] = json["units"][0]["id"]
except IndexError:
pass
else:
json["uid"] = current_unit.id
response = jsonify(json)
return HttpResponse(response, mimetype="application/json")
@ajax_required
@get_store_context('view')
def get_view_units_store(request, store, limit=0):
"""Gets source and target texts excluding the editing widget (store-level).
:return: An object in JSON notation that contains the source and target
texts for units that will be displayed before and after
unit ``uid``.
"""
return get_view_units(request, store.units, store=True, limit=limit)
def _is_filtered(request):
"""Checks if unit list is filtered."""
return ('filter' in request.GET or 'checks' in request.GET or
'user' in request.GET or
('search' in request.GET and 'sfields' in request.GET))
@ajax_required
@get_unit_context('view')
def get_more_context(request, unit):
"""Retrieves more context units.
:return: An object in JSON notation that contains the source and target
texts for units that are in the context of unit ``uid``.
"""
store = request.store
json = {}
gap = int(request.GET.get('gap', 0))
qty = int(request.GET.get('qty', 1))
json["ctx"] = _filter_ctx_units(store.units, unit, qty, gap)
rcode = 200
response = jsonify(json)
return HttpResponse(response, status=rcode, mimetype="application/json")
@never_cache
@get_unit_context('view')
def timeline(request, unit):
"""Returns a JSON-encoded string including the changes to the unit
rendered in HTML.
"""
timeline = Submission.objects.filter(unit=unit, field__in=[
SubmissionFields.TARGET, SubmissionFields.STATE,
SubmissionFields.COMMENT
])
timeline = timeline.select_related("submitter__user",
"translation_project__language")
context = {}
entries_group = []
import locale
from pootle_store.fields import to_python
for key, values in groupby(timeline, key=lambda x: x.creation_time):
entry_group = {
'datetime': key,
'datetime_str': key.strftime(locale.nl_langinfo(locale.D_T_FMT)),
'entries': [],
}
for item in values:
# Only add submitter information for the whole entry group once
entry_group.setdefault('submitter', item.submitter)
context.setdefault('language', item.translation_project.language)
entry = {
'field': item.field,
'field_name': SubmissionFields.NAMES_MAP[item.field],
}
if item.field == SubmissionFields.STATE:
entry['old_value'] = STATES_MAP[int(to_python(item.old_value))]
entry['new_value'] = STATES_MAP[int(to_python(item.new_value))]
else:
entry['new_value'] = to_python(item.new_value)
entry_group['entries'].append(entry)
entries_group.append(entry_group)
# Let's reverse the chronological order
entries_group.reverse()
# Remove first timeline item if it's solely a change to the target
if (entries_group and len(entries_group[0]['entries']) == 1 and
entries_group[0]['entries'][0]['field'] == SubmissionFields.TARGET):
del entries_group[0]
context['entries_group'] = entries_group
if request.is_ajax():
# The client will want to confirm that the response is relevant for
# the unit on screen at the time of receiving this, so we add the uid.
json = {'uid': unit.id}
t = loader.get_template('unit/xhr-timeline.html')
c = RequestContext(request, context)
json['timeline'] = t.render(c).replace('\n', '')
response = simplejson.dumps(json)
return HttpResponse(response, mimetype="application/json")
else:
return render_to_response('unit/timeline.html', context,
context_instance=RequestContext(request))
@ajax_required
@get_unit_context('translate')
def comment(request, unit):
"""Stores a new comment for the given ``unit``.
:return: If the form validates, the cleaned comment is returned.
An error message is returned otherwise.
"""
# Update current unit instance's attributes
unit.commented_by = request.profile
unit.commented_on = timezone.now()
language = request.translation_project.language
form = unit_comment_form_factory(language)(request.POST, instance=unit,
request=request)
if form.is_valid():
form.save()
context = {
'unit': unit,
'language': language,
}
t = loader.get_template('unit/comment.html')
c = RequestContext(request, context)
json = {'comment': t.render(c)}
rcode = 200
else:
json = {'msg': _("Comment submission failed.")}
rcode = 400
response = simplejson.dumps(json)
return HttpResponse(response, status=rcode, mimetype="application/json")
@never_cache
@ajax_required
@get_unit_context('view')
def get_edit_unit(request, unit):
"""Given a store path ``pootle_path`` and unit id ``uid``, gathers all the
necessary information to build the editing widget.
:return: A templatised editing widget is returned within the ``editor``
variable and paging information is also returned if the page
number has changed.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(instance=unit)
comment_form_class = unit_comment_form_factory(language)
comment_form = comment_form_class({}, instance=unit)
store = unit.store
directory = store.parent
profile = request.profile
alt_src_langs = get_alt_src_langs(request, profile, translation_project)
project = translation_project.project
report_target = ensure_uri(project.report_target)
suggestions = get_sugg_list(unit)
template_vars = {
'unit': unit,
'form': form,
'comment_form': comment_form,
'store': store,
'directory': directory,
'profile': profile,
'user': request.user,
'language': language,
'source_language': translation_project.project.source_language,
'cantranslate': check_profile_permission(profile, "translate",
directory),
'cansuggest': check_profile_permission(profile, "suggest", directory),
'canreview': check_profile_permission(profile, "review", directory),
'altsrcs': find_altsrcs(unit, alt_src_langs, store=store,
project=project),
'report_target': report_target,
'suggestions': suggestions,
}
if translation_project.project.is_terminology or store.is_terminology:
t = loader.get_template('unit/term_edit.html')
else:
t = loader.get_template('unit/edit.html')
c = RequestContext(request, template_vars)
json['editor'] = t.render(c)
rcode = 200
# Return context rows if filtering is applied but
# don't return any if the user has asked not to have it
current_filter = request.GET.get('filter', 'all')
show_ctx = request.COOKIES.get('ctxShow', 'true')
if ((_is_filtered(request) or current_filter not in ('all',)) and
show_ctx == 'true'):
# TODO: review if this first 'if' branch makes sense
if translation_project.project.is_terminology or store.is_terminology:
json['ctx'] = _filter_ctx_units(store.units, unit, 0)
else:
ctx_qty = int(request.COOKIES.get('ctxQty', 1))
json['ctx'] = _filter_ctx_units(store.units, unit, ctx_qty)
response = jsonify(json)
return HttpResponse(response, status=rcode, mimetype="application/json")
def get_failing_checks(request, pathobj):
"""Gets a list of failing checks for the current object.
:return: JSON string with a list of failing check categories which
include the actual checks that are failing.
"""
stats = get_raw_stats(pathobj)
failures = get_quality_check_failures(pathobj, stats, include_url=False)
response = jsonify(failures)
return HttpResponse(response, mimetype="application/json")
@ajax_required
@get_store_context('view')
def get_failing_checks_store(request, store):
return get_failing_checks(request, store)
@ajax_required
@get_unit_context('')
def submit(request, unit):
"""Processes translation submissions and stores them in the database.
:return: An object in JSON notation that contains the previous and last
units for the unit next to unit ``uid``.
"""
json = {}
cantranslate = check_permission("translate", request)
if not cantranslate:
raise PermissionDenied(_("You do not have rights to access "
"translation mode."))
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
# Store current time so that it is the same for all submissions
current_time = timezone.now()
# Update current unit instance's attributes
unit.submitted_by = request.profile
unit.submitted_on = current_time
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit)
if form.is_valid():
if form.updated_fields:
for field, old_value, new_value in form.updated_fields:
sub = Submission(
creation_time=current_time,
translation_project=translation_project,
submitter=request.profile,
unit=unit,
field=field,
type=SubmissionTypes.NORMAL,
old_value=old_value,
new_value=new_value,
)
sub.save()
form.save()
translation_submitted.send(
sender=translation_project,
unit=form.instance,
profile=request.profile,
)
rcode = 200
else:
# Form failed
#FIXME: we should display validation errors here
rcode = 400
json["msg"] = _("Failed to process submission.")
response = jsonify(json)
return HttpResponse(response, status=rcode, mimetype="application/json")
@ajax_required
@get_unit_context('')
def suggest(request, unit):
"""Processes translation suggestions and stores them in the database.
:return: An object in JSON notation that contains the previous and last
units for the unit next to unit ``uid``.
"""
json = {}
cansuggest = check_permission("suggest", request)
if not cansuggest:
raise PermissionDenied(_("You do not have rights to access "
"translation mode."))
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit)
if form.is_valid():
if form.instance._target_updated:
# TODO: Review if this hackish method is still necessary
#HACKISH: django 1.2 stupidly modifies instance on
# model form validation, reload unit from db
unit = Unit.objects.get(id=unit.id)
sugg = unit.add_suggestion(form.cleaned_data['target_f'],
request.profile)
if sugg:
SuggestionStat.objects.get_or_create(
translation_project=translation_project,
suggester=request.profile, state='pending', unit=unit.id
)
rcode = 200
else:
# Form failed
#FIXME: we should display validation errors here
rcode = 400
json["msg"] = _("Failed to process suggestion.")
response = jsonify(json)
return HttpResponse(response, status=rcode, mimetype="application/json")
@ajax_required
@get_unit_context('')
def reject_suggestion(request, unit, suggid):
json = {}
translation_project = request.translation_project
json["udbid"] = unit.id
json["sugid"] = suggid
if request.POST.get('reject'):
try:
sugg = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
if (not check_permission('review', request) and
(not request.user.is_authenticated() or sugg and
sugg.user != request.profile)):
raise PermissionDenied(_("You do not have rights to access "
"review mode."))
success = unit.reject_suggestion(suggid)
if sugg is not None and success:
# FIXME: we need a totally different model for tracking stats, this
# is just lame
suggstat, created = SuggestionStat.objects.get_or_create(
translation_project=translation_project,
suggester=sugg.user,
state='pending',
unit=unit.id,
)
suggstat.reviewer = request.profile
suggstat.state = 'rejected'
suggstat.save()
response = jsonify(json)
return HttpResponse(response, mimetype="application/json")
@ajax_required
@get_unit_context('review')
def accept_suggestion(request, unit, suggid):
json = {
'udbid': unit.id,
'sugid': suggid,
}
translation_project = request.translation_project
if request.POST.get('accept'):
try:
suggestion = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
old_target = unit.target
success = unit.accept_suggestion(suggid)
json['newtargets'] = [highlight_whitespace(target)
for target in unit.target.strings]
json['newdiffs'] = {}
for sugg in unit.get_suggestions():
json['newdiffs'][sugg.id] = \
[highlight_diffs(unit.target.strings[i], target)
for i, target in enumerate(sugg.target.strings)]
if suggestion is not None and success:
if suggestion.user:
translation_submitted.send(sender=translation_project,
unit=unit, profile=suggestion.user)
# FIXME: we need a totally different model for tracking stats, this
# is just lame
suggstat, created = SuggestionStat.objects.get_or_create(
translation_project=translation_project,
suggester=suggestion.user,
state='pending',
unit=unit.id,
)
suggstat.reviewer = request.profile
suggstat.state = 'accepted'
suggstat.save()
# For now assume the target changed
# TODO: check all fields for changes
creation_time = timezone.now()
sub = Submission(
creation_time=creation_time,
translation_project=translation_project,
submitter=suggestion.user,
from_suggestion=suggstat,
unit=unit,
field=SubmissionFields.TARGET,
type=SubmissionTypes.SUGG_ACCEPT,
old_value=old_target,
new_value=unit.target,
)
sub.save()
response = jsonify(json)
return HttpResponse(response, mimetype="application/json")
@ajax_required
def clear_vote(request, voteid):
json = {}
json["voteid"] = voteid
if request.POST.get('clear'):
try:
from voting.models import Vote
vote = Vote.objects.get(pk=voteid)
if vote.user != request.user:
# No i18n, will not go to UI
raise PermissionDenied("Users can only remove their own votes")
vote.delete()
except ObjectDoesNotExist:
raise Http404
response = jsonify(json)
return HttpResponse(response, mimetype="application/json")
@ajax_required
@get_unit_context('')
def vote_up(request, unit, suggid):
json = {}
json["suggid"] = suggid
if request.POST.get('up'):
try:
suggestion = unit.suggestion_set.get(id=suggid)
from voting.models import Vote
# Why can't it just return the vote object?
Vote.objects.record_vote(suggestion, request.user, +1)
json["voteid"] = Vote.objects.get_for_user(suggestion,
request.user).id
except ObjectDoesNotExist:
raise Http404(_("The suggestion or vote is not valid any more."))
response = jsonify(json)
return HttpResponse(response, mimetype="application/json")
@ajax_required
@get_unit_context('review')
def reject_qualitycheck(request, unit, checkid):
json = {}
json["udbid"] = unit.id
json["checkid"] = checkid
if request.POST.get('reject'):
try:
check = unit.qualitycheck_set.get(id=checkid)
check.false_positive = True
check.save()
# update timestamp
unit.save()
except ObjectDoesNotExist:
raise Http404
response = jsonify(json)
return HttpResponse(response, mimetype="application/json")
|
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 7 14:02:01 2018
@author: jie-yu
"""
import numpy as np
np.random.seed(1337) # for reproducibility
#from keras.datasets import mnist
from keras.models import Model
from keras.layers import Dense, Input
import matplotlib.pyplot as plt
from PIL import Image
import os
labels = np.load("img_labels.npy")
y_train = np.zeros((len(labels),1))#len(labels)
#def hot_to_num():
for i in range(len(labels)):#len(labels)
y_train[i] = np.where(labels[i]==1)[0][0]
#image = Image.open("hw3_img.jpg")
os.chdir('D:\\Jie-Yu\\碩一上\\智慧型\\期末project\\img\\img')
filelist = os.listdir()
x = np.zeros((len(filelist),150*150))
for i in range(len(filelist)):
IMG = Image.open(filelist[i])
x[i,:]=np.array(IMG.getdata())
x_train = x.copy()
x_test = x_train.copy()
y_test = y_train.copy()
# download the mnist to the path '~/.keras/datasets/' if it is the first time to be called
# X shape (60,000 28x28), y shape (10,000, )
#(x_train, y_train), (x_test, y_test) = mnist.load_data()
# data pre-processing
x_train = x_train.astype('float32') / 255. - 0.5 # minmax_normalized
x_test = x_test.astype('float32') / 255. - 0.5 # minmax_normalized
x_train = x_train.reshape((x_train.shape[0], -1))
x_test = x_test.reshape((x_test.shape[0], -1))
print(x_train.shape)
print(x_test.shape)
# in order to plot in a 2D figure
encoding_dim = 2
# this is our input placeholder
input_img = Input(shape=(150*150,))
# encoder layers
encoded = Dense(128, activation='relu')(input_img)
encoded = Dense(64, activation='relu')(encoded)
encoded = Dense(10, activation='relu')(encoded)
encoder_output = Dense(encoding_dim)(encoded)
# decoder layers
decoded = Dense(10, activation='relu')(encoder_output)
decoded = Dense(64, activation='relu')(decoded)
decoded = Dense(128, activation='relu')(decoded)
decoded = Dense(150*150, activation='tanh')(decoded)
# construct the autoencoder model
autoencoder = Model(input=input_img, output=decoded)
# construct the encoder model for plotting
encoder = Model(input=input_img, output=encoder_output)
# compile autoencoder
autoencoder.compile(optimizer='adam', loss='mse')
# training
autoencoder.fit(x_train, x_train,
nb_epoch=20,
batch_size=256,
shuffle=True)
"""
Epoch 20/20
60000/60000 [==============================] - 7s - loss: 0.0398
"""
# plotting
encoded_imgs = encoder.predict(x_test)
plt.scatter(encoded_imgs[:, 0], encoded_imgs[:, 1], c=y_test)
plt.colorbar()
plt.show()
def lda(X,L):
Classes = np.unique(np.array(L))#0,1,2
k = len(Classes)#k = 3
n = np.zeros((k,1))#3*1 array
C = [" "]*k #3*1 list
M = np.mean(X,axis = 0) #X的mean
S = [" "]*k #3*1 list
Sw = 0
Sb = 0
for j in range(k):#3
Xj = X[np.where(L==Classes[j])[0]]
n[j] = int(Xj.shape[0])
C[j] = np.mean(Xj,axis = 0)
S[j] = 0
for i in range(int(n[j])):
aaa = np.array([Xj[i,:]-C[j]])
S[j] = S[j]+np.dot(aaa.T,aaa)
Sw = Sw+S[j]
bbb = np.array([C[j]-M])
Sb = Sb+int(n[j])*np.dot(bbb.T,bbb)
tmp = np.dot(np.linalg.inv(Sw),Sb)
LAMBDA,W = np.linalg.eig(tmp)
SortOrder = np.argsort(-LAMBDA)
# print(W)
W = W[:,SortOrder[0:1]]
Y = np.dot(X,W)
Y = -Y
return Y,W
Y,W = lda(encoded_imgs,np.array(y_test))#降成一維的特徵
Y_sort = np.squeeze(Y).argsort()
Y_list = []
for i in range(len(Y_sort)):
aaa = (x_test[Y_sort[i]]+0.5)*255
Y_list.append(aaa.reshape(150,150).T.astype('uint8'))
Y_list = np.array(Y_list)
def draw_func(a,b):
start = min(a,b)
end = max(a,b)
if end-start>10:
jump = (end-start)//10
draw = Y_list[range(start,end,jump)]
draw = draw.reshape((len(range(start,end,jump)))*150,150)
else:
draw = Y_list[start:end]
draw = draw.reshape((end-start)*150,150)
draw = draw.T
Image.fromarray(draw).show()
#draw = np.array(Y_list)
draw_func(500,510)
#draw_func(500,502)
#draw_func(502,503)
|
##
# Hardware.py: Class implementing control of WEINBot alarm tones via GPIO.
#
# Copyright 2015, Egan McComb
#
##
import Adafruit_BBIO.GPIO as GPIO
import threading
import time
import logging
class Alarm():
"""
Alarm: A class that provides an interface to control the WEINBot STI
minicontroller alarm and tones (5 bit selector) via GPIO.
http://www.sti-usa.com/pdf/specs/SA5000.pdf
"""
# Alarm tone aliases. See page 5 of the documentation for a list of tones.
aliases = {
"water": 1,
"waste": 3,
"rev": 5,
"gen": 7
}
def __init__(self, pin_enable="P8_26", pins_selector=("P8_21", "P8_22", "P8_23", "P8_24", "P8_25")):
"""
pin_enable: BBB GPIO pin controlling alarm on/off.
pins_selector: BBB GPIO pins for tone selector.
"""
# Set up GPIO.
self.go = False
self.pin_enable = pin_enable
GPIO.setup(pin_enable, GPIO.OUT)
self.pins_selector = pins_selector
for pin in pins_selector:
GPIO.setup(pin, GPIO.OUT)
return None
def __del__(self):
self.stop()
return
def start(self):
"""
start: Start the alarm.
"""
logging.debug("alarm: started")
self.go = True
GPIO.output(self.pin_enable, GPIO.HIGH)
def strobe(self, tone, time_spec):
"""
strobe: Strobe alarm tone according to time.
tone: Tone or alias to produce.
time_spec: List of times for toggle (s).
"""
self.setTone(tone)
t = threading.Thread(target=self.__handler, args=(time_spec,))
t.start()
def __handler(self, time_spec):
logging.debug("alarm: strobe started")
for t in time_spec:
self.toggle()
time.sleep(t)
self.toggle()
logging.debug("alarm: strobe stopped")
def setTone(self, tone):
"""
setTone: Set the alarm tone.
tone: Tone number or alias to produce.
"""
# Determine tone number (decimal).
if tone in self.aliases:
tone = self.aliases[tone]
elif tone in range(1, 33):
tone -= 1
else:
logging.debug("setTone: invalid tone number or alias")
return -1
# Pause alarm if needed.
if self.go:
self.stop()
self.go = True
# Write tone selector bits.
if (tone & 0x1):
GPIO.output(self.pins_selector[0], GPIO.HIGH)
else:
GPIO.output(self.pins_selector[0], GPIO.LOW)
if (tone & 0x2):
GPIO.output(self.pins_selector[1], GPIO.HIGH)
else:
GPIO.output(self.pins_selector[1], GPIO.LOW)
if (tone & 0x4):
GPIO.output(self.pins_selector[2], GPIO.HIGH)
else:
GPIO.output(self.pins_selector[2], GPIO.LOW)
if (tone & 0x8):
GPIO.output(self.pins_selector[3], GPIO.HIGH)
else:
GPIO.output(self.pins_selector[3], GPIO.LOW)
if (tone & 0x10):
GPIO.output(self.pins_selector[4], GPIO.HIGH)
else:
GPIO.output(self.pins_selector[4], GPIO.LOW)
logging.debug("setTone: %d" %(tone))
# Resume alarm if needed.
if self.go:
self.start()
def toggle(self):
"""
toggle: Toggle alarm state.
"""
if self.go:
self.stop()
else:
self.start()
def stop(self):
"""
stop: Stop the alarm.
"""
logging.debug("alarm: stopped")
self.go = False
GPIO.output(self.pin_enable, GPIO.LOW)
|
from cheetax.exceptions import RuntimeException
class RunManager(object):
"""
RunManager is responsible for handling runners
based on its status.
"""
def __init__(self):
self.runners = []
self.total_time = 0
@property
def num_runners(self):
return len(self.runners)
def add_runner(self, runner):
self.runners.append(runner)
def call_runner(self, runner, index, total):
runner.before_execute(index, total)
result = runner.run()
runner.after_execute(result, index, total)
self.total_time = self.total_time + result.execution_time
if result.errored and runner.raise_on_first_error():
raise RuntimeException(result.error)
return result
def execute_runners(self):
for index, runner in enumerate(self.runners):
if index == 0:
runner.initial_msg()
result = self.call_runner(runner, index, len(self.runners))
if index == self.num_runners-1:
runner.final_msg(result, self.num_runners, self.total_time)
|
"""
Contains possible interactions with the Apollo's Annotations
"""
import logging
import sys
import time
from enum import Enum
from timeit import default_timer
from BCBio import GFF
from apollo import util
from apollo.client import Client
from apollo.util import features_to_feature_schema, retry
log = logging.getLogger()
class FeatureType(Enum):
FEATURE = 1
TRANSCRIPT = 2
class AnnotationsClient(Client):
CLIENT_BASE = '/annotationEditor/'
def _update_data(self, data, organism=None, sequence=None):
if sequence and organism:
self.set_sequence(organism, sequence)
if not hasattr(self, '_extra_data'):
raise Exception("Please call setSequence first")
data.update(self._extra_data)
return data
def set_sequence(self, organism, sequence):
"""
Set the sequence for subsequent requests. Mostly used in client scripts
to avoid passing the sequence and organism on every function call.
:type organism: str
:param organism: Organism Name
:type sequence: str
:param sequence: Sequence Name
:rtype: None
:return: None
"""
self._extra_data = {
'sequence': sequence,
'organism': organism,
}
def set_description(self, feature_id, description, organism=None, sequence=None):
"""
Set a feature's description
:type feature_id: str
:param feature_id: Feature UUID
:type description: str
:param description: Feature description
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'description': description,
}
]
}
data = self._update_data(data, sequence, organism)
return self.post('setDescription', data)
def set_name(self, feature_id, name, organism=None, sequence=None):
"""
Set a feature's name
:type feature_id: str
:param feature_id: Feature UUID
:type name: str
:param name: Feature name
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'name': name,
}
],
}
data = self._update_data(data, organism, sequence)
return self.post('setName', data)
def set_status(self, feature_id, status, organism=None, sequence=None):
"""
Set a feature's description
:type feature_id: str
:param feature_id: Feature UUID
:type status: str
:param status: Feature status
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'status': status,
}
],
}
data = self._update_data(data, organism, sequence)
return self.post('setStatus', data)
def set_symbol(self, feature_id, symbol, organism=None, sequence=None):
"""
Set a feature's description
:type feature_id: str
:param feature_id: Feature UUID
:type symbol: str
:param symbol: Feature symbol
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'symbol': symbol,
}
],
}
data = self._update_data(data, organism, sequence)
return self.post('setSymbol', data)
def get_comments(self, feature_id, organism=None, sequence=None):
"""
Get a feature's comments
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
}
],
}
data = self._update_data(data, organism, sequence)
return self.post('getComments', data)
def add_comment(self, feature_id, comments=[], organism=None, sequence=None):
"""
Set a feature's description
:type feature_id: str
:param feature_id: Feature UUID
:type comments: list
:param comments: Feature comments
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'comments': comments
}
],
}
data = self._update_data(data, organism, sequence)
return self.post('addComments', data)
def add_attribute(self, feature_id, attribute_key, attribute_value, organism=None, sequence=None):
"""
Add an attribute to a feature
:type feature_id: str
:param feature_id: Feature UUID
:type attribute_key: str
:param attribute_key: Attribute Key
:type attribute_value: str
:param attribute_value: Attribute Value
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
This seems to show two attributes being added, but it behaves like those two are one.
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'non_reserved_properties': [
{
'tag': attribute_key,
'value': attribute_value,
}
]
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('addAttribute', data)
def delete_attribute(self, feature_id, attribute_key, attribute_value, organism=None, sequence=None):
"""
Delete an attribute from a feature
:type feature_id: str
:param feature_id: Feature UUID
:type attribute_key: str
:param attribute_key: Attribute Key
:type attribute_value: str
:param attribute_value: Attribute Value
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'non_reserved_properties': [
{
'tag': attribute_key,
'value': attribute_value
}
]
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('deleteAttribute', data)
def update_attribute(self, feature_id, attribute_key, old_value, new_value, organism=None, sequence=None):
"""
Delete an attribute from a feature
:type feature_id: str
:param feature_id: Feature UUID
:type attribute_key: str
:param attribute_key: Attribute Key
:type old_value: str
:param old_value: Old attribute value
:type new_value: str
:param new_value: New attribute value
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'old_non_reserved_properties': [
{
'tag': attribute_key,
'value': old_value,
}
],
'new_non_reserved_properties': [
{
'tag': attribute_key,
'value': new_value,
}
]
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('deleteAttribute', data)
def add_dbxref(self, feature_id, db, accession, organism=None, sequence=None):
"""
Add a dbxref to a feature
:type feature_id: str
:param feature_id: Feature UUID
:type db: str
:param db: DB Name (e.g. PMID)
:type accession: str
:param accession: Accession Value
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
This seems to show two attributes being added, but it behaves like those two are one.
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'dbxrefs': [
{
'db': db,
'accession': accession,
}
]
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('addDbxref', data)
def delete_dbxref(self, feature_id, db, accession, organism=None, sequence=None):
"""
Delete a dbxref from a feature
:type feature_id: str
:param feature_id: Feature UUID
:type db: str
:param db: DB Name (e.g. PMID)
:type accession: str
:param accession: Accession Value
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'dbxrefs': [
{
'db': db,
'accession': accession,
}
]
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('deleteDbxref', data)
def update_dbxref(self, feature_id, old_db, old_accession, new_db, new_accession, organism=None, sequence=None):
"""
Delete a dbxref from a feature
:type feature_id: str
:param feature_id: Feature UUID
:type old_db: str
:param old_db: Old DB Name (e.g. PMID)
:type old_accession: str
:param old_accession: Old accession Value
:type new_db: str
:param new_db: New DB Name (e.g. PMID)
:type new_accession: str
:param new_accession: New accession Value
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
'old_dbxrefs': [
{
'db': old_db,
'accession': old_accession,
}
],
'new_dbxrefs': [
{
'db': new_db,
'accession': new_accession,
}
]
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('deleteDbxref', data)
def get_features(self, organism=None, sequence=None):
"""
Get the features for an organism / sequence
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {}
data = self._update_data(data, organism, sequence)
return self.post('getFeatures', data)
def get_feature_sequence(self, feature_id, organism=None, sequence=None):
"""
[CURRENTLY BROKEN] Get the sequence of a feature
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
# Choices: peptide, cds, cdna, genomic
# { "track": "Miro.v2", "features": [ { "uniquename": "714dcda6-2358-467d-855e-f495a82aa154" } ], "operation": "get_sequence", "type": "peptide" }:
# { "track": "Miro.v2", "features": [ { "uniquename": "714dcda6-2358-467d-855e-f495a82aa154" } ], "operation": "get_sequence", "flank": 500, "type": "genomic" }:
# This API is not behaving as expected. Wrong documentation?
data = {
'type': 'peptide',
'features': [
{'uniquename': feature_id}
]
}
data = self._update_data(data, organism, sequence)
return self.post('getSequence', data)
def add_features(self, features=[], organism=None, sequence=None):
"""
Add a list of feature
:type features: list
:param features: Feature information
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': features,
}
data = self._update_data(data, organism, sequence)
return self.post('addFeature', data)
def add_feature(self, feature={}, organism=None, sequence=None):
"""
Add a single feature
:type feature: dict
:param feature: Feature information
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
return self.add_features([feature], organism, sequence)
def add_transcripts(self, transcripts=[],
suppress_history=False, suppress_events=False, organism=None,
sequence=None
):
"""
Add a list of transcript annotations
:type transcripts: list
:param transcripts: Transcript data
:type suppress_history: bool
:param suppress_history: Suppress the history of this operation
:type suppress_events: bool
:param suppress_events: Suppress instant update of the user interface
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
if transcripts is None:
transcripts = []
data = {
'suppressHistory': suppress_history,
'suppressEvents': suppress_events,
'features': transcripts
}
data = self._update_data(data, organism, sequence)
return self.post('addTranscript', data)
def add_transcript(self, transcript={},
suppress_history=False, suppress_events=False, organism=None,
sequence=None
):
"""
Add a single transcript annotation
:type transcript: dict
:param transcript: Transcript data
:type suppress_history: bool
:param suppress_history: Suppress the history of this operation
:type suppress_events: bool
:param suppress_events: Suppress instant update of the user interface
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
return self.add_transcripts([transcript], suppress_history, suppress_events, organism, sequence)
def duplicate_transcript(self, transcript_id, organism=None, sequence=None):
"""
Duplicate a transcripte
:type transcript_id: str
:param transcript_id: Transcript UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': transcript_id
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('duplicateTranscript', data)
def set_translation_start(self, feature_id, start, organism=None, sequence=None):
"""
Set the translation start of a feature
:type feature_id: str
:param feature_id: Feature UUID
:type start: int
:param start: Feature start
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [{
'uniquename': feature_id,
'location': {
'fmin': start
}
}]
}
data = self._update_data(data, organism, sequence)
return self.post('setTranslationStart', data)
def set_translation_end(self, feature_id, end, organism=None, sequence=None):
"""
Set a feature's end
:type feature_id: str
:param feature_id: Feature UUID
:type end: int
:param end: Feature end
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [{
'uniquename': feature_id,
'location': {
'fmax': end
}
}]
}
data = self._update_data(data, organism, sequence)
return self.post('setTranslationEnd', data)
def set_longest_orf(self, feature_id, organism=None, sequence=None):
"""
Automatically pick the longest ORF in a feature
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('setLongestOrf', data)
def set_boundaries(self, feature_id, start, end, organism=None, sequence=None):
"""
Set the boundaries of a genomic feature
:type feature_id: str
:param feature_id: Feature UUID
:type start: int
:param start: Feature start
:type end: int
:param end: Feature end
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [{
'uniquename': feature_id,
'location': {
'fmin': start,
'fmax': end,
}
}]
}
data = self._update_data(data, organism, sequence)
return self.post('setBoundaries', data)
def set_readthrough_stop_codon(self, feature_id, organism=None, sequence=None):
"""
Set the feature to read through the first encountered stop codon
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [{
'uniquename': feature_id,
}]
}
data = self._update_data(data, organism, sequence)
return self.post('setReadthroughStopCodon', data)
def get_sequence_alterations(self, organism=None, sequence=None):
"""
[UNTESTED] Get all of the sequence's alterations
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: list
:return: A list of sequence alterations(?)
"""
data = {}
data = self._update_data(data, organism, sequence)
return self.post('getSequenceAlterations', data)
def delete_sequence_alteration(self, feature_id, organism=None, sequence=None):
"""
[UNTESTED] Delete a specific feature alteration
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: list
:return: A list of sequence alterations(?)
"""
data = {
'features': [{
'uniquename': feature_id,
}]
}
data = self._update_data(data, organism, sequence)
return self.post('deleteSequenceAlteration', data)
def flip_strand(self, feature_id, organism=None, sequence=None):
"""
Flip the strand of a feature
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('flipStrand', data)
def merge_exons(self, exon_a, exon_b, organism=None, sequence=None):
"""
Merge two exons
:type exon_a: str
:param exon_a: Feature UUID
:type exon_b: str
:param exon_b: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{'uniquename': exon_a},
{'uniquename': exon_b},
]
}
data = self._update_data(data, organism, sequence)
return self.post('mergeExons', data)
def delete_feature(self, feature_id, organism=None, sequence=None):
"""
Delete a feature
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: dict
:return: A standard apollo feature dictionary ({"features": [{...}]})
"""
data = {
'features': [
{
'uniquename': feature_id,
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('deleteFeature', data)
def get_search_tools(self):
"""
Get the search tools available
:rtype: dict
:return: dictionary containing the search tools and their metadata.
For example::
{
"sequence_search_tools": {
"blat_prot": {
"name": "Blat protein",
"search_class": "org.bbop.apollo.sequence.search.blat.BlatCommandLineProteinToNucleotide",
"params": "",
"search_exe": "/usr/local/bin/blat"
},
"blat_nuc": {
"name": "Blat nucleotide",
"search_class": "org.bbop.apollo.sequence.search.blat.BlatCommandLineNucleotideToNucleotide",
"params": "",
"search_exe": "/usr/local/bin/blat"
}
}
}
"""
return self.get('getSequenceSearchTools', {})
def get_gff3(self, feature_id, organism=None, sequence=None):
"""
Get the GFF3 associated with a feature
:type feature_id: str
:param feature_id: Feature UUID
:type organism: str
:param organism: Organism Common Name
:type sequence: str
:param sequence: Sequence Name
:rtype: str
:return: GFF3 text content
"""
data = {
'features': [
{
'uniquename': feature_id
}
]
}
data = self._update_data(data, organism, sequence)
return self.post('getGff3', data, is_json=False)
def load_legacy_gff3(self, organism, gff3, source=None):
"""
Load a full GFF3 into annotation track (legacy version, kept for compatibility only)
:type organism: str
:param organism: Organism Common Name
:type gff3: str
:param gff3: GFF3 to load
:type source: str
:param source: URL where the input dataset can be found.
:rtype: str
:return: Loading report
"""
sys.stdout.write('# ')
sys.stdout.write('\t'.join(['Feature ID', 'Apollo ID', 'Success', 'Messages']))
sys.stdout.write('\n')
bad_quals = ['date_creation', 'source', 'owner', 'date_last_modified', 'Name', 'ID']
for rec in GFF.parse(gff3):
self.set_sequence(organism, rec.id)
for feature in rec.features:
# We can only handle genes right now
if feature.type not in ('gene', 'terminator'):
continue
# Convert the feature into a presentation that Apollo will accept
feature_data = features_to_feature_schema([feature])
# TODO: do we handle all top-types here?
if 'children' in feature_data[0] and any([child['type']['name'] == 'tRNA'
for child in feature_data[0]['children']]):
# We're experiencing a (transient?) problem where gene_001 to
# gene_025 will be rejected. Thus, hardcode to a known working
# gene name and update later.
feature_data[0]['name'] = 'tRNA_000'
tRNA_sf = [child for child in feature.sub_features if child.type == 'tRNA'][0]
tRNA_type = 'tRNA-' + tRNA_sf.qualifiers.get('Codon', ["Unk"])[0]
if 'Name' in feature.qualifiers:
if feature.qualifiers['Name'][0].startswith('tRNA-'):
tRNA_type = feature.qualifiers['Name'][0]
newfeature = self.add_feature(feature_data[0])
def func0():
self.set_name(
newfeature['features'][0]['uniquename'],
tRNA_type,
)
retry(func0)
if source:
gene_id = newfeature['features'][0]['parent_id']
def setSource():
self.add_attribute(gene_id, 'DatasetSource', source)
retry(setSource)
sys.stdout.write('\t'.join([
feature.id,
newfeature['features'][0]['uniquename'],
'success',
]))
if feature_data[0]['type']['name'] == 'terminator':
# We're experiencing a (transient?) problem where gene_001 to
# gene_025 will be rejected. Thus, hardcode to a known working
# gene name and update later.
feature_data[0]['name'] = 'terminator_000'
newfeature = self.add_feature(feature_data[0])
def func0():
self.set_name(
newfeature['features'][0]['uniquename'],
'terminator'
)
retry(func0)
if source:
gene_id = newfeature['features'][0]['parent_id']
def setSource():
self.add_attribute(gene_id, 'DatasetSource', source)
retry(setSource)
sys.stdout.write('\t'.join([
feature.id,
newfeature['features'][0]['uniquename'],
'success',
]))
else:
try:
# We're experiencing a (transient?) problem where gene_001 to
# gene_025 will be rejected. Thus, hardcode to a known working
# gene name and update later.
feature_data[0]['name'] = 'gene_000'
# Create the new feature
newfeature = self.add_feature(feature_data[0])
# Extract the UUIDs that apollo returns to us
mrna_id = newfeature['features'][0]['uniquename']
gene_id = newfeature['features'][0]['parent_id']
# Sleep to give it time to actually persist the feature. Apollo
# is terrible about writing + immediately reading back written
# data.
time.sleep(1)
# Extract CDS feature from the feature data, this will be used
# to set the CDS location correctly (apollo currently screwing
# this up (2.0.6))
min_cds = None
max_cds = None
for feat in feature_data[0]['children']:
# mRNA level
for subfeat in feat['children']:
# Can be exon or CDS
if subfeat['type']['name'] == 'CDS':
if min_cds is None:
min_cds = subfeat['location']['fmin']
max_cds = subfeat['location']['fmax']
else:
min_cds = min(min_cds, subfeat['location']['fmin'])
max_cds = max(max_cds, subfeat['location']['fmax'])
if 'children' in subfeat:
for subsubfeat in subfeat['children']:
if subsubfeat['type']['name'] == 'CDS':
if min_cds is None:
min_cds = subsubfeat['location']['fmin']
max_cds = subsubfeat['location']['fmax']
else:
min_cds = min(min_cds, subsubfeat['location']['fmin'])
max_cds = max(max_cds, subsubfeat['location']['fmax'])
# Correct the translation start, but with strand specific log
if feature_data[0]['location']['strand'] == 1:
self.set_translation_start(mrna_id, min(min_cds, max_cds))
else:
self.set_translation_start(mrna_id, max(min_cds, max_cds) - 1)
# Finally we set the name, this should be correct.
def func():
self.set_name(mrna_id, feature.qualifiers.get('product',
feature.qualifiers.get('Name', ["Unknown"]))[
0])
retry(func)
def func():
self.set_name(gene_id, feature.qualifiers.get('product',
feature.qualifiers.get('Name', ["Unknown"]))[
0])
retry(func)
if source:
gene_id = newfeature['features'][0]['parent_id']
def setSource():
self.add_attribute(gene_id, 'DatasetSource', source)
retry(setSource)
extra_attr = {}
for (key, values) in feature.qualifiers.items():
if key in bad_quals:
continue
if key == 'Note':
def func2():
self.add_comments(gene_id, values)
retry(func2)
else:
extra_attr[key] = values
for key in extra_attr:
def func3():
self.add_attribute(gene_id, key, extra_attr[key])
retry(func3)
sys.stdout.write('\t'.join([
feature.id,
gene_id,
'success',
]))
except Exception as e:
msg = str(e)
if '\n' in msg:
msg = msg[0:msg.index('\n')]
sys.stdout.write('\t'.join([
feature.id,
'',
'ERROR',
msg
]))
sys.stdout.write('\n')
sys.stdout.flush()
def _check_write(self, batch_size, test, new_features_list=[], type=FeatureType.FEATURE, timing=False):
if len(new_features_list) >= batch_size:
log.debug("writing out: " + str(new_features_list))
returned = self._write_features(new_features_list, test, timing, type)
if 'error' in returned:
log.error("Error returned by Apollo while loading data: %s" % returned['error'])
return {top_in['gff_id']: 'error' for top_in in new_features_list}
elif len(returned):
# FIXME this can give strange results in case of error while loading some of the features.
# This expects the order to be preserved. It's the case in Apollo 2.6.0 at least.
in_ids = [top_in['gff_id'] for top_in in new_features_list]
return dict(zip(in_ids, returned['features']))
return {}
def _write_features(self, new_features_list=None, test=False, timing=False, feature_type=None):
if not isinstance(feature_type, FeatureType):
raise TypeError("Feature type must be of type feature type : " + str(feature_type))
if len(new_features_list) > 0:
returned_features = {}
log.debug("Writing " + str(len(new_features_list)) + " features")
log.debug("Features to write:")
log.debug(new_features_list)
if test:
print("test success " + str(len(new_features_list)) + " features would have been loaded")
else:
if timing:
start_time = default_timer()
try:
if feature_type == FeatureType.FEATURE:
returned_features = self.add_features(new_features_list)
elif feature_type == FeatureType.TRANSCRIPT:
returned_features = self.add_transcripts(new_features_list)
else:
raise Exception("Type '" + str(feature_type) + "' is unknown")
except Exception:
e = sys.exc_info()
log.error("Error writing: " + str(e))
returned_features = {'error': "Error writing: " + str(e)}
if timing:
end_time = default_timer()
duration = end_time - start_time
avg_duration = duration / len(new_features_list)
if len(new_features_list) > 1:
print('({:.1f}/{:.2f})'.format(duration, avg_duration))
else:
print('({:.2f})'.format(duration))
log.debug("Features returned: ")
log.debug(returned_features)
return returned_features
else:
log.debug("empty list, no more features to write")
return {}
def _get_type(self, rec):
return rec.features[0].type
def _get_subfeature_type(self, rec):
return rec.features[0].type
def _process_gff_entry(self, rec, source=None, disable_cds_recalculation=False, use_name=False):
new_feature_list = []
new_transcript_list = []
type = self._get_type(rec)
log.debug("type " + str(type))
for feature in rec.features:
feature_data = None
if type in util.gene_types:
log.debug("is gene type")
if len(feature.sub_features) > 0:
feature_data = util.yieldApolloData(feature, use_name=use_name,
disable_cds_recalculation=disable_cds_recalculation)
log.debug("output feature data" + str(feature_data))
if isinstance(feature_data, list):
new_transcript_list += feature_data
else:
new_transcript_list.append(feature_data)
else:
log.debug("NO sub features, just adding directly")
feature_data = util.yieldApolloData(feature, use_name=use_name,
disable_cds_recalculation=disable_cds_recalculation)
log.debug("output feature data" + str(feature_data))
new_feature_list.append(feature_data)
elif type in util.pseudogenes_types:
feature_data = util.yieldApolloData(feature, use_name=use_name,
disable_cds_recalculation=disable_cds_recalculation)
if isinstance(feature_data, list):
new_feature_list += feature_data
else:
new_feature_list.append(feature_data)
elif type in util.coding_transcript_types:
feature_data = util.yieldApolloData(feature, use_name=use_name,
disable_cds_recalculation=disable_cds_recalculation)
new_transcript_list.append(feature_data)
elif type in util.noncoding_transcript_types:
log.debug("a non-coding transcript")
feature_data = util.yieldApolloData(feature, use_name=use_name,
disable_cds_recalculation=disable_cds_recalculation)
new_feature_list.append(feature_data)
log.debug("new feature list " + str(new_feature_list))
elif type in util.single_level_feature_types:
feature_data = util.yieldApolloData(feature, use_name=use_name,
disable_cds_recalculation=disable_cds_recalculation)
new_feature_list.append(feature_data)
else:
log.debug("unknown type " + type + " ")
return {'top-level': new_feature_list, 'transcripts': new_transcript_list}
def load_gff3(self, organism, gff3, source=None, batch_size=1,
test=False,
use_name=False,
disable_cds_recalculation=False,
timing=False,
):
"""
Load a full GFF3 into annotation track
:type organism: str
:param organism: Organism Common Name
:type gff3: str
:param gff3: GFF3 to load
:type source: str
:param source: URL where the input dataset can be found.
:type batch_size: int
:param batch_size: Size of batches before writing
:type test: bool
:param test: Run in dry run mode
:type use_name: bool
:param use_name: Use the given name instead of generating one.
:type disable_cds_recalculation: bool
:param disable_cds_recalculation: Disable CDS recalculation and instead use the one provided
:type timing: bool
:param timing: Output loading performance metrics
:rtype: str
:return: Loading report
"""
organisms = self._wa.organisms.get_organisms()
org_ids = []
for org in organisms:
if organism == org['commonName'] or organism == str(org['id']):
org_ids.append(org['id'])
if len(org_ids) == 0:
raise Exception("Organism name or id not found [" + organism + "]")
if len(org_ids) > 1:
raise Exception("More than one organism found for [" + organism + "]. Use an organism ID instead: " + str(
org_ids))
total_features_written = 0
start_timer = default_timer()
if timing:
print('Times are in seconds. If batch-size > 1 then .(total_batch_time/avg_feature_time)')
all_processed = {'top-level': [], 'transcripts': []}
loading_status = {}
for rec in GFF.parse(gff3):
self.set_sequence(organism, rec.id)
try:
log.info("Processing %s with features: %s" % (rec.id, rec.features))
processed = self._process_gff_entry(rec, source=source,
disable_cds_recalculation=disable_cds_recalculation,
use_name=use_name
)
all_processed['top-level'].extend(processed['top-level'])
all_processed['transcripts'].extend(processed['transcripts'])
total_features_written += 1
written_top = self._check_write(batch_size, test, all_processed['top-level'], FeatureType.FEATURE, timing)
written_transcripts = self._check_write(batch_size, test, all_processed['transcripts'], FeatureType.TRANSCRIPT, timing)
if len(written_top):
all_processed['top-level'] = []
loading_status = {**loading_status, **written_top}
if len(written_transcripts):
all_processed['transcripts'] = []
loading_status = {**loading_status, **written_transcripts}
except Exception as e:
msg = str(e)
if '\n' in msg:
msg = msg[0:msg.index('\n')]
log.error("Failed to load features from %s" % rec.id)
# Write the rest of things to write (ignore batch_size)
written_top = self._check_write(0, test, all_processed['top-level'], FeatureType.FEATURE, timing)
written_transcripts = self._check_write(0, test, all_processed['transcripts'], FeatureType.TRANSCRIPT, timing)
if len(written_top):
all_processed['top-level'] = []
loading_status = {**loading_status, **written_top}
if len(written_transcripts):
all_processed['transcripts'] = []
loading_status = {**loading_status, **written_transcripts}
log.info("Finished loading")
if timing:
end_timer = default_timer()
duration = end_timer - start_timer
print(str(duration) + " seconds to write " + str(total_features_written) + " features")
print("Avg write time (s) per feature: " + str('{:.3f}'.format(duration / total_features_written)))
return loading_status
|
# _______ _______ __ __ _______ __ __ _______
# | _ || || |_| || || | | || _ |
# | |_| || _ || || _ || | | || |_| |
# | || | | | | | | |_| || |_| || |
# | _ | | |_| | | | | ___|| || _ |
# | |_| || || _ || | | || |_| |
# |_______||_______||__| |__||___| |_______||_______|
#
# Copyright (c) 2014 Steve Ivy <[email protected]>
#
import logging
import imp
from datetime import datetime
import jinja2
import markdown
import re
import requests
import dropbox
import json
from dropbox import client, session
# from dropbox.rest import ErrorResponse
from werkzeug.routing import BaseConverter
from flask import Flask, request, make_response
from postutils import split_markdown, process_markdown
CONFIG_FILE = '/etc/boxpub/config.py'
def load_config(config_file):
try:
config = imp.load_source('config', config_file)
return config
except IOError:
LOG.critical('Could not load config at %s.' % config_file)
sys.exit(1)
CONFIG = load_config(CONFIG_FILE)
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s %(module)s.%(funcName)s (%(lineno)d) %(levelname)s: %(message)s'
)
log = logging.getLogger('boxpub')
format = logging.Formatter(
'%(asctime)s %(module)s.%(funcName)s (%(lineno)d) %(levelname)s: %(message)s')
fh = logging.FileHandler(CONFIG.LOGFILE)
fh.setLevel(getattr(logging, CONFIG.LOGLEVEL.upper()))
log.addHandler(fh)
boxpub = Flask('boxpub')
boxpub.debug = True
def render_template(template_string, context):
template_globals = {
'HOST': request.host,
# 'PAGE_URL_FULL': request.path_url,
'QUERY_STRING': request.query_string,
'URL': request.url,
'PATH': request.path,
'settings': CONFIG,
'config': CONFIG,
'site': CONFIG.SITE_DATA,
'time': datetime.now(),
}
template_globals.update(context)
jinja_environment = jinja2.Environment(
extensions=['jinja2.ext.autoescape'])
template = jinja_environment.from_string(template_string)
resp_body = template.render(template_globals)
return resp_body
def render_file_with_template(target_file, target_template):
"""
"""
client = dropbox.client.DropboxClient(CONFIG.DROPBOX_PRIVATE_TOKEN)
file_response, dropbox_meta = client.get_file_and_metadata(
target_file)
file_content = file_response.read()
f = process_markdown(
target_file, file_content)
log.debug(f)
if 'meta' in f:
fmeta = f['meta']
fmeta.update(dropbox_meta)
f['meta'] = fmeta
else:
f['meta'] = dropbox_meta
# data['published'] = data['modified']
# data['created'] = data['modified']
# merge 'meta' values with other values
f.update(f['meta'])
# fix title
if 'Title' in f:
f['title'] = f['Title']
# permalink
f['permalink'] = url_for_path(f['path'])
template_response, meta = client.get_file_and_metadata(
'templates/%s' % target_template)
template_content = template_response.read()
page_content = render_template(template_content, {
'page': f,
'post': f,
})
return page_content
def url_for_path(path):
if 'posts' in path:
year, month, day, filename = re.match(
'/posts/([\d]{4})-([\d]{2})-([\d]{2})-([\w-]+)\.md',
path).groups()
return "/%s/%s/%s/%s" % (year, month, day, filename)
elif 'page' in path:
filename = re.match(
'/pages/([\w-]+)\.md',
path).group(1)
return "/pages/%s" % filename
class RegexConverter(BaseConverter):
def __init__(self, url_map, *items):
super(RegexConverter, self).__init__(url_map)
self.regex = items[0]
boxpub.url_map.converters['regex'] = RegexConverter
############################################################
# web handlers
#
@boxpub.route('/webhooks/dropbox', methods=['GET'])
def dropbox_webhook_verify():
log.info('Dropbox verification request')
return request.args.get('challenge')
@boxpub.route('/webhooks/dropbox', methods=['POST'])
def dropbox_webhook_handle():
log.info('Dropbox post request')
url = CONFIG.SITE_DATA['url']
try:
log.info('PURGING site index')
purge_resp = requests.request('PURGE', url)
log.debug(purge_resp.text)
resp = make_response(purge_resp.text)
except Exception, e:
log.exception(e)
resp = make_response("ERR: " + e.message)
log.debug(resp)
return resp
@boxpub.route('/')
def blog_index_handle(template='index.html', content_type='text/html'):
log.debug('blog_index_handle()')
target_file = "posts"
client = dropbox.client.DropboxClient(CONFIG.DROPBOX_PRIVATE_TOKEN)
dropbox_response = client.metadata(
target_file, list=True)
files = dropbox_response['contents']
files = sorted(
files,
key=lambda f: f['path'],
reverse=True)
files = files[:10]
log.debug(files)
for f in files:
log.debug(f['path'])
file_response, dropbox_meta = client.get_file_and_metadata(
f['path'])
f.update(dropbox_meta)
log.debug(f['path'])
file_content = file_response.read()
fdata = process_markdown(
target_file, file_content)
log.debug(fdata)
f.update(fdata)
log.debug(f['path'])
# fix title
f.update(f['meta'])
if 'Title' in f:
f['title'] = f['Title']
# permalink
f['permalink'] = url_for_path(f['path'])
log.debug(f)
# log.debug(files)
template_response, meta = client.get_file_and_metadata(
'templates/%s' % template)
template_content = template_response.read()
page_content = render_template(template_content, {
'posts': files,
})
resp = make_response(page_content)
resp.headers["Content-Type"] = content_type
return resp
@boxpub.route('/atom.xml')
def blog_feed_handle(template='atom.xml'):
return blog_index_handle(template, 'application/atom+xml')
@boxpub.route('/page/<page>')
def blog_page_handle(page, template='post.html'):
log.debug('blog_page_handle()')
target_file = "/pages/%s.md" % (page)
page_content = render_file_with_template(target_file, template)
return page_content
@boxpub.route('/<regex("[\d]{4}"):year>/<regex("[\d]{2}"):month>/<regex("[\d]{2}"):day>/<filename>')
def blog_post_handle(year, month, day, filename, template='post.html'):
log.debug('blog_post_handle()')
log.info('Dropbox post request')
target_file = "/posts/%s-%s-%s-%s.md" % (year, month, day, filename)
page_content = render_file_with_template(target_file, template)
return page_content
if __name__ == "__main__":
boxpub.run(host='0.0.0.0')
|
# -*- coding: utf-8 -*-
"""
Human Resource Management
"""
module = request.controller
resourcename = request.function
if module not in deployment_settings.modules:
raise HTTP(404, body="Module disabled: %s" % module)
s3db.hrm_vars(module)
# =============================================================================
def index():
""" Dashboard """
mode = session.s3.hrm.mode
if mode is not None:
redirect(URL(f="person"))
tablename = "hrm_human_resource"
table = s3db.hrm_human_resource
roles = session.s3.roles or []
if ADMIN not in roles:
orgs = session.s3.hrm.orgs or [None]
org_filter = (table.organisation_id.belongs(orgs))
else:
# Admin can see all Orgs
org_filter = (table.organisation_id > 0)
s3mgr.configure(tablename,
insertable=False,
list_fields=["id",
"person_id",
"job_title",
"type",
"site_id"])
response.s3.filter = org_filter
# Parse the Request
r = s3base.S3Request(s3mgr, prefix="hrm", name="human_resource")
# Pre-process
# Only set the method to search if it is not an ajax dataTable call
# This fixes a problem with the dataTable where the the filter had a
# distinct in the sql which cause a ticket to be raised
if r.representation != "aadata":
r.method = "search"
r.custom_action = s3db.hrm_human_resource_search
# Execute the request
output = r()
if r.representation == "aadata":
return output
# Post-process
response.s3.actions = [dict(label=str(T(messages["UPDATE"])),
_class="action-btn",
url=URL(f="person",
args=["human_resource"],
vars={"human_resource.id": "[id]"}))]
if r.interactive:
output["module_name"] = response.title
if session.s3.hrm.orgname:
output["orgname"] = session.s3.hrm.orgname
response.view = "hrm/index.html"
query = (table.deleted != True) & \
(table.status == 1) & org_filter
# Staff
ns = db(query & (table.type == 1)).count()
# Volunteers
nv = db(query & (table.type == 2)).count()
output["ns"] = ns
output["nv"] = nv
try:
module_name = deployment_settings.modules[module].name_nice
except:
module_name = T("Human Resources Management")
response.title = module_name
output["title"] = module_name
return output
# =============================================================================
# People
# =============================================================================
def human_resource():
"""
HR Controller
"""
tablename = "hrm_human_resource"
table = s3db[tablename]
# Must specify a group to create HRs
# Interactive
group = request.vars.get("group", None)
if group == None:
# Imports
groupCode = request.vars.get("human_resource.type", None)
if groupCode == "2":
group = "volunteer"
elif groupCode == "1":
group = "staff"
if group == "volunteer":
_type = table.type
_type.default = 2
response.s3.filter = (_type == 2)
_type.readable = False
_type.writable = False
_location = table.location_id
_location.writable = True
_location.readable = True
_location.label = T("Home Address")
table.site_contact.writable = False
table.site_contact.readable = False
list_fields = ["id",
"person_id",
"job_title",
"organisation_id",
"location_id",
"status",
]
s3mgr.configure(tablename,
list_fields = list_fields)
table.job_title.label = T("Volunteer Role")
s3.crud_strings[tablename].update(
title_create = T("Add Volunteer"),
title_display = T("Volunteer Information"),
title_list = T("Volunteers"),
title_search = T("Search Volunteers"),
subtitle_create = T("Add New Volunteer"),
subtitle_list = T("Volunteers"),
label_create_button = T("Add Volunteer"),
msg_record_created = T("Volunteer added"))
# Remove inappropriate filters from the Search widget
human_resource_search = s3mgr.model.get_config(tablename,
"search_method")
# Facility
human_resource_search._S3Search__advanced.pop(6)
# Type
human_resource_search._S3Search__advanced.pop(1)
s3mgr.configure(tablename,
search_method = human_resource_search)
elif group == "staff":
#s3mgr.configure(table._tablename, insertable=False)
# Default to Staff
_type = table.type
_type.default = 1
response.s3.filter = (_type == 1)
_type.readable = False
_type.writable = False
table.site_id.writable = True
table.site_id.readable = True
list_fields = ["id",
"person_id",
"job_title",
"organisation_id",
"site_id",
"site_contact",
"end_date",
"status",
]
s3mgr.configure(tablename,
list_fields = list_fields)
s3.crud_strings[tablename].update(
title_create = T("Add Staff Member"),
title_list = T("Staff"),
title_search = T("Search Staff"),
title_upload = T("Import Staff & Volunteers"),
)
if "expiring" in request.get_vars:
response.s3.filter = response.s3.filter & \
(table.end_date < (request.utcnow + datetime.timedelta(weeks=4)))
s3.crud_strings[tablename].title_list = T("Staff with Contracts Expiring in the next Month")
# Remove the big Add button
s3mgr.configure(tablename,
insertable=False)
# Remove Type filter from the Search widget
human_resource_search = s3mgr.model.get_config(tablename,
"search_method")
human_resource_search._S3Search__advanced.pop(1)
s3mgr.configure(tablename,
search_method = human_resource_search)
def prep(r):
if r.interactive:
# Assume volunteers only between 12-81
s3db.pr_person.date_of_birth.widget = S3DateWidget(past=972, future=-144)
table = r.table
table.site_id.comment = DIV(DIV(_class="tooltip",
_title="%s|%s|%s" % (T("Facility"),
T("The site where this position is based."),
T("Enter some characters to bring up a list of possible matches."))))
if r.method != "read":
# Don't want to see in Create forms
# inc list_create (list_fields over-rides)
field = table.status
field.writable = False
field.readable = False
if r.method == "create" and r.component is None:
if group in (1, 2):
field = table.type
field.readable = False
field.writable = False
elif r.representation == "plain":
# Don't redirect Map popups
pass
elif r.id:
# Redirect to person controller
vars = {"human_resource.id": r.id}
if group:
vars.update(group=group)
redirect(URL(f="person",
vars=vars))
return True
response.s3.prep = prep
def postp(r, output):
if r.interactive:
if not r.component:
s3_action_buttons(r, deletable=False)
if "msg" in deployment_settings.modules:
# @ToDo: Remove this now that we have it in Events?
response.s3.actions.append({
"url": URL(f="compose",
vars = {"hrm_id": "[id]"}),
"_class": "action-btn",
"label": str(T("Send Message"))})
elif r.representation == "plain":
# Map Popups
output = hrm_map_popup(r)
return output
response.s3.postp = postp
output = s3_rest_controller(interactive_report=True)
return output
# -----------------------------------------------------------------------------
def hrm_map_popup(r):
"""
Custom output to place inside a Map Popup
- called from postp of human_resource controller
"""
output = TABLE()
append = output.append
# Edit button
append(TR(TD(A(T("Edit"),
_target="_blank",
_id="edit-btn",
_href=URL(args=[r.id, "update"])))))
# First name, last name
append(TR(TD(B("%s:" % T("Name"))),
TD(s3_fullname(r.record.person_id))))
# Job Title
if r.record.job_title:
append(TR(TD(B("%s:" % r.table.job_title.label)),
TD(r.record.job_title)))
# Organization (better with just name rather than Represent)
# @ToDo: Make this configurable - some deployments will only see
# their staff so this is a meaningless field
#table = s3db.org_organisation
#query = (table.id == r.record.organisation_id)
#name = db(query).select(table.name,
# limitby=(0, 1)).first().name
#append(TR(TD(B("%s:" % r.table.organisation_id.label)),
# TD(name)))
# Components link to the Person record
person_id = r.record.person_id
# Skills
table = s3db.hrm_competency
stable = s3db.hrm_skill
query = (table.person_id == person_id) & \
(table.skill_id == stable.id)
skills = db(query).select(stable.name)
if skills:
vals = [skill.name for skill in skills]
if len(skills) > 1:
represent = ", ".join(vals)
else:
represent = len(vals) and vals[0] or ""
append(TR(TD(B("%s:" % T("Skills"))),
TD(represent)))
# Certificates
table = s3db.hrm_certification
ctable = s3db.hrm_certificate
query = (table.person_id == person_id) & \
(table.certificate_id == ctable.id)
certificates = db(query).select(ctable.name)
if certificates:
vals = [cert.name for cert in certificates]
if len(certificates) > 1:
represent = ", ".join(vals)
else:
represent = len(vals) and vals[0] or ""
append(TR(TD(B("%s:" % T("Certificates"))),
TD(represent)))
# Trainings
table = s3db.hrm_training
etable = s3db.hrm_training_event
ctable = s3db.hrm_course
query = (table.person_id == person_id) & \
(table.training_event_id == etable.id) & \
(etable.course_id == ctable.id)
trainings = db(query).select(ctable.name)
if trainings:
vals = [train.name for train in trainings]
if len(trainings) > 1:
represent = ", ".join(vals)
else:
represent = len(vals) and vals[0] or ""
append(TR(TD(B("%s:" % T("Trainings"))),
TD(represent)))
if r.record.location_id:
table = s3db.gis_location
query = (table.id == r.record.location_id)
location = db(query).select(table.path,
table.addr_street,
limitby=(0, 1)).first()
# City
# Street address
if location.addr_street:
append(TR(TD(B("%s:" % table.addr_street.label)),
TD(location.addr_street)))
# Mobile phone number
ptable = s3db.pr_person
ctable = s3db.pr_contact
query = (ptable.id == person_id) & \
(ctable.pe_id == ptable.pe_id)
contacts = db(query).select(ctable.contact_method,
ctable.value)
email = mobile_phone = ""
for contact in contacts:
if contact.contact_method == "EMAIL":
email = contact.value
elif contact.contact_method == "SMS":
mobile_phone = contact.value
if mobile_phone:
append(TR(TD(B("%s:" % msg.CONTACT_OPTS.get("SMS"))),
TD(mobile_phone)))
# Office number
if r.record.site_id:
table = s3db.org_office
query = (table.site_id == r.record.site_id)
office = db(query).select(table.phone1,
limitby=(0, 1)).first()
if office and office.phone1:
append(TR(TD(B("%s:" % T("Office Phone"))),
TD(office.phone1)))
else:
# @ToDo: Support other Facility Types (Hospitals & Shelters)
pass
# Email address (as hyperlink)
if email:
append(TR(TD(B("%s:" % msg.CONTACT_OPTS.get("EMAIL"))),
TD(A(email, _href="mailto:%s" % email))))
return output
# -----------------------------------------------------------------------------
def person():
"""
Person Controller
- used for Personal Profile & Imports
- includes components relevant to HRM
@ToDo: Volunteers should be redirected to vol/person?
"""
# Custom Method for Contacts
s3mgr.model.set_method("pr", resourcename,
method="contacts",
action=s3db.pr_contacts)
if deployment_settings.has_module("asset"):
# Assets as component of people
s3mgr.model.add_component("asset_asset",
pr_person="assigned_to_id")
# Edits should always happen via the Asset Log
# @ToDo: Allow this method too, if we can do so safely
s3mgr.configure("asset_asset",
insertable = False,
editable = False,
deletable = False)
group = request.get_vars.get("group", "staff")
hr_id = request.get_vars.get("human_resource.id", None)
if not str(hr_id).isdigit():
hr_id = None
mode = session.s3.hrm.mode
# Configure human resource table
tablename = "hrm_human_resource"
table = s3db[tablename]
if hr_id and str(hr_id).isdigit():
hr = table[hr_id]
if hr:
group = hr.type == 2 and "volunteer" or "staff"
# Also inform the back-end of this finding
request.get_vars["group"] = group
org = session.s3.hrm.org
if org is not None:
table.organisation_id.default = org
table.organisation_id.comment = None
table.organisation_id.readable = False
table.organisation_id.writable = False
table.site_id.requires = IS_EMPTY_OR(IS_ONE_OF(db,
"org_site.%s" % super_key(db.org_site),
s3db.org_site_represent,
filterby="organisation_id",
filter_opts=[session.s3.hrm.org]))
if hr_id:
if group == "staff":
table.site_id.writable = True
table.site_id.readable = True
else:
# Volunteer
table.location_id.writable = True
table.location_id.readable = True
table.location_id.label = T("Home Address")
else:
table.location_id.readable = True
table.site_id.readable = True
if session.s3.hrm.mode is not None:
s3mgr.configure(tablename,
list_fields=["id",
"organisation_id",
"type",
"job_title",
"status",
"location_id",
"site_id"])
else:
s3mgr.configure(tablename,
list_fields=["id",
"type",
"job_title",
"status",
"location_id",
"site_id"])
# Configure person table
# - hide fields
tablename = "pr_person"
table = s3db[tablename]
table.pe_label.readable = False
table.pe_label.writable = False
table.missing.readable = False
table.missing.writable = False
table.age_group.readable = False
table.age_group.writable = False
s3mgr.configure(tablename,
deletable=False)
if group == "staff":
s3.crud_strings[tablename].update(
title_upload = T("Import Staff"))
# No point showing the 'Occupation' field - that's the Job Title in the Staff Record
table.occupation.readable = False
table.occupation.writable = False
# Just have a Home Address
table = s3db.pr_address
table.type.default = 1
table.type.readable = False
table.type.writable = False
_crud = s3.crud_strings.pr_address
_crud.title_create = T("Add Home Address")
_crud.title_update = T("Edit Home Address")
s3mgr.model.add_component("pr_address",
pr_pentity=dict(joinby=super_key(s3db.pr_pentity),
multiple=False))
# Default type for HR
table = s3db.hrm_human_resource
table.type.default = 1
request.get_vars.update(xsltmode="staff")
else:
s3.crud_strings[tablename].update(
title_upload = T("Import Volunteers"))
# Default type for HR
table = db.hrm_human_resource
table.type.default = 2
request.get_vars.update(xsltmode="volunteer")
if session.s3.hrm.mode is not None:
# Configure for personal mode
s3db.hrm_human_resource.organisation_id.readable = True
s3.crud_strings[tablename].update(
title_display = T("Personal Profile"),
title_update = T("Personal Profile"))
# People can view their own HR data, but not edit it
s3mgr.configure("hrm_human_resource",
insertable = False,
editable = False,
deletable = False)
s3mgr.configure("hrm_certification",
insertable = True,
editable = True,
deletable = True)
s3mgr.configure("hrm_credential",
insertable = False,
editable = False,
deletable = False)
s3mgr.configure("hrm_competency",
insertable = True, # Can add unconfirmed
editable = False,
deletable = False)
s3mgr.configure("hrm_training", # Can add but not provide grade
insertable = True,
editable = False,
deletable = False)
s3mgr.configure("hrm_experience",
insertable = False,
editable = False,
deletable = False)
s3mgr.configure("pr_group_membership",
insertable = False,
editable = False,
deletable = False)
else:
# Configure for HR manager mode
s3.crud_strings[tablename].update(
title_upload = T("Import Staff & Volunteers"))
if group == "staff":
s3.crud_strings[tablename].update(
title_display = T("Staff Member Details"),
title_update = T("Staff Member Details"))
elif group == "volunteer":
s3.crud_strings[tablename].update(
title_display = T("Volunteer Details"),
title_update = T("Volunteer Details"))
# Upload for configuration (add replace option)
response.s3.importerPrep = lambda: dict(ReplaceOption=T("Remove existing data before import"))
# Import pre-process
def import_prep(data, group=group):
"""
Deletes all HR records (of the given group) of the organisation
before processing a new data import, used for the import_prep
hook in s3mgr
"""
request = current.request
resource, tree = data
xml = s3mgr.xml
tag = xml.TAG
att = xml.ATTRIBUTE
if response.s3.import_replace:
if tree is not None:
if group == "staff":
group = 1
elif group == "volunteer":
group = 2
else:
return # don't delete if no group specified
root = tree.getroot()
expr = "/%s/%s[@%s='org_organisation']/%s[@%s='name']" % \
(tag.root, tag.resource, att.name, tag.data, att.field)
orgs = root.xpath(expr)
for org in orgs:
org_name = org.get("value", None) or org.text
if org_name:
try:
org_name = json.loads(s3mgr.xml.xml_decode(org_name))
except:
pass
if org_name:
htable = s3db.hrm_human_resource
otable = s3db.org_organisation
query = (otable.name == org_name) & \
(htable.organisation_id == otable.id) & \
(htable.type == group)
resource = s3mgr.define_resource("hrm", "human_resource", filter=query)
ondelete = s3mgr.model.get_config("hrm_human_resource", "ondelete")
resource.delete(ondelete=ondelete, format="xml", cascade=True)
s3mgr.import_prep = import_prep
# CRUD pre-process
def prep(r):
if r.representation == "s3json":
s3mgr.show_ids = True
elif r.interactive and r.method != "import":
if r.component:
if r.component_name == "asset":
# Edits should always happen via the Asset Log
# @ToDo: Allow this method too, if we can do so safely
s3mgr.configure("asset_asset",
insertable = False,
editable = False,
deletable = False)
else:
# Assume volunteers only between 12-81
r.table.date_of_birth.widget = S3DateWidget(past=972, future=-144)
resource = r.resource
if mode is not None:
r.resource.build_query(id=s3_logged_in_person())
else:
if not r.id and not hr_id:
# pre-action redirect => must retain prior errors
if response.error:
session.error = response.error
redirect(URL(r=r, f="human_resource"))
if resource.count() == 1:
resource.load()
r.record = resource.records().first()
if r.record:
r.id = r.record.id
if not r.record:
session.error = T("Record not found")
redirect(URL(f="human_resource",
args=["search"], vars={"group":group}))
if hr_id and r.component_name == "human_resource":
r.component_id = hr_id
s3mgr.configure("hrm_human_resource",
insertable = False)
if not r.component_id or r.method in ("create", "update"):
address_hide(s3db.pr_address)
return True
response.s3.prep = prep
# CRUD post-process
def postp(r, output):
if r.interactive and r.component and r.component_name == "asset":
# Provide a link to assign a new Asset
# @ToDo: Proper Widget to do this inline
output["add_btn"] = A(T("Assign Asset"),
_href=URL(c="asset", f="asset"),
_id="add-btn",
_class="action-btn")
return output
response.s3.postp = postp
# REST Interface
if session.s3.hrm.orgname and mode is None:
orgname = session.s3.hrm.orgname
else:
orgname = None
output = s3_rest_controller("pr", resourcename,
native=False,
rheader=s3db.hrm_rheader,
orgname=orgname,
replace_option=T("Remove existing data before import"))
return output
# =============================================================================
# Teams
# =============================================================================
def group():
"""
Team controller
- uses the group table from PR
"""
tablename = "pr_group"
table = s3db[tablename]
_group_type = table.group_type
_group_type.label = T("Team Type")
table.description.label = T("Team Description")
table.name.label = T("Team Name")
mtable = s3db.pr_group_membership
mtable.group_id.label = T("Team ID")
mtable.group_head.label = T("Team Leader")
# Set Defaults
_group_type.default = 3 # 'Relief Team'
_group_type.readable = _group_type.writable = False
# Only show Relief Teams
# Do not show system groups
response.s3.filter = (table.system == False) & \
(_group_type == 3)
# CRUD Strings
ADD_TEAM = T("Add Team")
LIST_TEAMS = T("List Teams")
s3.crud_strings[tablename] = Storage(
title_create = ADD_TEAM,
title_display = T("Team Details"),
title_list = LIST_TEAMS,
title_update = T("Edit Team"),
title_search = T("Search Teams"),
subtitle_create = T("Add New Team"),
subtitle_list = T("Teams"),
label_list_button = LIST_TEAMS,
label_create_button = T("Add New Team"),
label_search_button = T("Search Teams"),
msg_record_created = T("Team added"),
msg_record_modified = T("Team updated"),
msg_record_deleted = T("Team deleted"),
msg_list_empty = T("No Teams currently registered"))
s3.crud_strings["pr_group_membership"] = Storage(
title_create = T("Add Member"),
title_display = T("Membership Details"),
title_list = T("Team Members"),
title_update = T("Edit Membership"),
title_search = T("Search Member"),
subtitle_create = T("Add New Member"),
subtitle_list = T("Current Team Members"),
label_list_button = T("List Members"),
label_create_button = T("Add Team Member"),
label_delete_button = T("Delete Membership"),
msg_record_created = T("Team Member added"),
msg_record_modified = T("Membership updated"),
msg_record_deleted = T("Membership deleted"),
msg_list_empty = T("No Members currently registered"))
s3mgr.configure(tablename, main="name", extra="description",
# Redirect to member list when a new group has been created
create_next = URL(f="group",
args=["[id]", "group_membership"]))
s3mgr.configure("pr_group_membership",
list_fields=["id",
"person_id",
"group_head",
"description"])
# Post-process
def postp(r, output):
if r.interactive:
if not r.component:
update_url = URL(args=["[id]", "group_membership"])
s3_action_buttons(r, deletable=False, update_url=update_url)
if "msg" in deployment_settings.modules:
response.s3.actions.append({
"url": URL(f="compose",
vars = {"group_id": "[id]"}),
"_class": "action-btn",
"label": str(T("Send Notification"))})
return output
response.s3.postp = postp
tabs = [
(T("Team Details"), None),
# Team should be contacted either via the Leader or
# simply by sending a message to the group as a whole.
#(T("Contact Data"), "contact"),
(T("Members"), "group_membership")
]
output = s3_rest_controller("pr", resourcename,
rheader=lambda r: s3db.pr_rheader(r, tabs=tabs))
return output
# =============================================================================
# Jobs
# =============================================================================
def job_role():
""" Job Roles Controller """
mode = session.s3.hrm.mode
def prep(r):
if mode is not None:
r.error(403, message=auth.permission.INSUFFICIENT_PRIVILEGES)
return True
response.s3.prep = prep
output = s3_rest_controller()
return output
# =============================================================================
# Skills
# =============================================================================
def skill():
""" Skills Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
output = s3_rest_controller()
return output
def skill_type():
""" Skill Types Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
output = s3_rest_controller()
return output
# -----------------------------------------------------------------------------
def competency_rating():
""" Competency Rating for Skill Types Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
output = s3_rest_controller()
return output
# -----------------------------------------------------------------------------
def skill_competencies():
"""
Called by S3FilterFieldChange to provide the competency options for a
particular Skill Type
"""
table = s3db.hrm_skill
ttable = s3db.hrm_skill_type
rtable = s3db.hrm_competency_rating
query = (table.id == request.args[0]) & \
(table.skill_type_id == ttable.id) & \
(rtable.skill_type_id == table.skill_type_id)
records = db(query).select(rtable.id,
rtable.name,
orderby=~rtable.priority)
response.headers["Content-Type"] = "application/json"
return records.json()
# -----------------------------------------------------------------------------
def skill_provision():
""" Skill Provisions Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
output = s3_rest_controller()
return output
# -----------------------------------------------------------------------------
def course():
""" Courses Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
output = s3_rest_controller(rheader=s3db.hrm_rheader)
return output
# -----------------------------------------------------------------------------
def course_certificate():
""" Courses to Certificates Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
output = s3_rest_controller()
return output
# -----------------------------------------------------------------------------
def certificate():
""" Certificates Controller """
mode = session.s3.hrm.mode
def prep(r):
if mode is not None:
r.error(403, message=auth.permission.INSUFFICIENT_PRIVILEGES)
return True
response.s3.prep = prep
output = s3_rest_controller(rheader=s3db.hrm_rheader)
return output
# -----------------------------------------------------------------------------
def certificate_skill():
""" Certificates to Skills Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
output = s3_rest_controller()
return output
# -----------------------------------------------------------------------------
def training():
""" Training Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
roles = session.s3.roles or []
if ADMIN not in roles and \
EDITOR not in roles:
ttable = s3db.hrm_training
hrtable = s3db.hrm_human_resource
orgtable = s3db.org_organisation
orgs = session.s3.hrm.orgs
query = (ttable.person_id == hrtable.person_id) & \
(hrtable.organisation_id == orgtable.id) & \
(orgtable.pe_id.belongs(orgs))
response.s3.filter = query
output = s3_rest_controller(interactive_report = True)
return output
# -----------------------------------------------------------------------------
def training_event():
""" Training Events Controller """
mode = session.s3.hrm.mode
if mode is not None:
session.error = T("Access denied")
redirect(URL(f="index"))
def prep(r):
if r.interactive and r.component:
# Use appropriate CRUD strings
s3.crud_strings["hrm_training"] = Storage(
title_create = T("Add Participant"),
title_display = T("Participant Details"),
title_list = T("Participants"),
title_update = T("Edit Participant"),
title_search = T("Search Participants"),
title_upload = T("Import Participant Participants"),
subtitle_create = T("Add Participant"),
subtitle_list = T("Participants"),
label_list_button = T("List Participants"),
label_create_button = T("Add New Participant"),
label_delete_button = T("Delete Participant"),
msg_record_created = T("Participant added"),
msg_record_modified = T("Participant updated"),
msg_record_deleted = T("Participant deleted"),
msg_no_match = T("No entries found"),
msg_list_empty = T("Currently no Participants registered"))
return True
response.s3.prep = prep
output = s3_rest_controller(rheader=s3db.hrm_rheader)
return output
# =============================================================================
def staff_org_site_json():
"""
Used by the Asset - Assign to Person page
"""
table = s3db.hrm_human_resource
otable = s3db.org_organisation
#db.req_commit.date.represent = lambda dt: dt[:10]
query = (table.person_id == request.args[0]) & \
(table.organisation_id == otable.id)
records = db(query).select(table.site_id,
otable.id,
otable.name)
response.headers["Content-Type"] = "application/json"
return records.json()
# =============================================================================
# Messaging
# =============================================================================
def compose():
""" Send message to people/teams """
vars = request.vars
if "hrm_id" in vars:
id = vars.hrm_id
fieldname = "hrm_id"
table = s3db.pr_person
htable = s3db.hrm_human_resource
query = (htable.id == id) & \
(htable.person_id == table.id)
title = T("Send a message to this person")
elif "group_id" in request.vars:
id = request.vars.group_id
fieldname = "group_id"
table = s3db.pr_group
query = (table.id == id)
title = T("Send a message to this team")
else:
session.error = T("Record not found")
redirect(URL(f="index"))
pe = db(query).select(table.pe_id,
limitby=(0, 1)).first()
if not pe:
session.error = T("Record not found")
redirect(URL(f="index"))
pe_id = pe.pe_id
if "hrm_id" in vars:
# Get the individual's communications options & preference
ctable = s3db.pr_contact
contact = db(ctable.pe_id == pe_id).select(ctable.contact_method,
orderby="priority",
limitby=(0, 1)).first()
if contact:
s3db.msg_outbox.pr_message_method.default = contact.contact_method
else:
session.error = T("No contact method found")
redirect(URL(f="index"))
# URL to redirect to after message sent
url = URL(c=module,
f="compose",
vars={fieldname: id})
# Create the form
output = msg.compose(recipient = pe_id,
url = url)
output["title"] = title
response.view = "msg/compose.html"
return output
# END =========================================================================
|
import time
from Code import ControlPosicion
from Code import Gestor
from Code import Jugada
from Code import TurnOnLights
from Code.QT import QTUtil
from Code.QT import QTUtil2
from Code.Constantes import *
class GestorTurnOnLights(Gestor.Gestor):
def inicio(self, num_theme, num_block, tol):
if hasattr(self, "reiniciando"):
if self.reiniciando:
return
self.reiniciando = True
self.num_theme = num_theme
self.num_block = num_block
self.tol = tol
self.block = self.tol.get_block(self.num_theme, self.num_block)
self.block.shuffle()
self.calculation_mode = self.tol.is_calculation_mode()
self.penaltyError = self.block.penaltyError(self.calculation_mode)
self.penaltyHelp = self.block.penaltyHelp(self.calculation_mode)
# self.factorDistancia = self.block.factorDistancia() # No se usa es menor que 1.0
self.av_seconds = self.block.av_seconds()
if self.av_seconds:
cat, ico = self.block.cqualification(self.calculation_mode)
self.lb_previous = "%s - %0.2f\"" % (cat, self.av_seconds)
else:
self.lb_previous = None
self.num_line = 0
self.num_lines = len(self.block)
self.num_moves = 0
self.total_time_used = 0.0
self.ayudas = 0
self.errores = 0
self.dicFENayudas = {} # se muestra la flecha a partir de dos del mismo
self.tipoJuego = kJugEntLight
self.siJuegaHumano = False
self.siTutorActivado = False
self.pantalla.ponActivarTutor(False)
self.ayudasPGN = 0
self.pantalla.activaJuego(True, False, siAyudas=False)
self.pantalla.quitaAyudas(True, True)
self.ponMensajero(self.mueveHumano)
self.mostrarIndicador(True)
self.reiniciando = False
self.next_line_run()
def pon_rotulos(self, next):
r1 = _("Calculation mode") if self.calculation_mode else _("Memory mode")
r1 += "<br>%s" % self.line.label
if self.lb_previous:
r1 += "<br><b>%s</b>" % self.lb_previous
if self.num_line:
av_secs, txt = self.block.calc_current(self.num_line - 1, self.total_time_used, self.errores, self.ayudas, self.calculation_mode)
r1 += "<br><b>%s: %s - %0.2f\"" % (_("Current"), txt, av_secs)
self.ponRotulo1(r1)
if next is not None:
r2 = "<b>%d/%d</b>" % (self.num_line + next, self.num_lines)
else:
r2 = None
self.ponRotulo2(r2)
def next_line(self):
if self.num_line < self.num_lines:
self.line = self.block.line(self.num_line)
self.num_move = -1
self.ini_time = None
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.line.fen)
self.partida.reset(cp)
siBlancas = cp.siBlancas
self.siJugamosConBlancas = siBlancas
self.siRivalConBlancas = not siBlancas
self.ponPosicion(self.partida.ultPosicion)
self.ponPiezasAbajo(siBlancas)
self.pgnRefresh(True)
self.partida.pendienteApertura = False
self.pon_rotulos(1)
def next_line_run(self):
liOpciones = [k_mainmenu, k_ayuda, k_reiniciar]
self.pantalla.ponToolBar(liOpciones)
self.next_line()
QTUtil.xrefreshGUI()
self.ponPosicionDGT()
self.estado = kJugando
self.siguienteJugada()
def procesarAccion(self, clave):
if clave == k_mainmenu:
self.finPartida()
elif clave == k_ayuda:
self.ayuda()
elif clave == k_reiniciar:
self.reiniciar()
elif clave == k_configurar:
self.configurar(siSonidos=True, siCambioTutor=False)
elif clave == k_utilidades:
self.utilidades()
elif clave == k_siguiente:
self.next_line_run()
def reiniciar(self):
if self.estado == kJugando:
if self.ini_time:
self.total_time_used += time.time() - self.ini_time
if self.total_time_used:
self.block.new_reinit(self.total_time_used, self.errores, self.ayudas)
self.total_time_used = 0.0
TurnOnLights.write_tol(self.tol)
self.inicio(self.num_theme, self.num_block, self.tol)
def siguienteJugada(self):
if self.estado == kFinJuego:
return
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.ultPosicion.siBlancas
self.ponIndicador(siBlancas)
self.refresh()
siRival = siBlancas == self.siRivalConBlancas
self.num_move += 1
if self.num_move >= self.line.total_moves():
self.finLinea()
return
if siRival:
pv = self.line.get_move(self.num_move)
desde, hasta, coronacion = pv[:2], pv[2:4], pv[4:]
self.mueveRival(desde, hasta, coronacion)
self.siguienteJugada()
else:
self.siJuegaHumano = True
self.base_time = time.time()
if not (self.calculation_mode and self.ini_time is None): # Se inicia salvo que sea el principio de la linea
self.ini_time = self.base_time
self.activaColor(siBlancas)
if self.calculation_mode:
self.tablero.setDispatchMove(self.dispatchMove)
def dispatchMove(self):
if self.ini_time is None:
self.ini_time = time.time()
def finLinea(self):
self.num_line += 1
islast_line = self.num_line == self.num_lines
if islast_line:
#Previous
ant_tm = self.block.av_seconds()
ant_done = self.tol.done_level()
ant_cat_level, nada = self.tol.cat_num_level()
ant_cat_global = self.tol.cat_global()
num_moves = self.block.num_moves()
ta = self.total_time_used + self.errores*self.penaltyError + self.ayudas*self.penaltyHelp
tm = ta/num_moves
self.block.new_result(tm, self.total_time_used, self.errores, self.ayudas)
TurnOnLights.write_tol(self.tol)
cat_block, ico = TurnOnLights.qualification(tm, self.calculation_mode)
cat_level, ico = self.tol.cat_num_level()
cat_global = self.tol.cat_global()
txt_more_time = ""
txt_more_cat = ""
txt_more_line = ""
txt_more_global = ""
if ant_tm is None or tm < ant_tm:
txt_more_time = '<span style="color:red">%s</span>' % _("New record")
done = self.tol.done_level()
if done and (not ant_done):
if not self.tol.islast_level():
txt_more_line = "%s<hr>" % _("Open the next level")
if cat_level != ant_cat_level:
txt_more_cat = '<span style="color:red">%s</span>' % _("New")
if cat_global != ant_cat_global:
txt_more_global = '<span style="color:red">%s</span>' % _("New")
cErrores = '<tr><td align=right> %s </td><td> %d (x%d"=%d")</td></tr>' % (_('Errors'), self.errores, self.penaltyError, self.errores*self.penaltyError) if self.errores else ""
cAyudas = '<tr><td align=right> %s </td><td> %d (x%d"=%d")</td></tr>' % (_('Hints'), self.ayudas, self.penaltyHelp, self.ayudas*self.penaltyHelp) if self.ayudas else ""
mens = ('<hr><center><big>'+_('You have finished this block of positions') +
'<hr><table>' +
'<tr><td align=right> %s </td><td> %0.2f"</td></tr>' % (_('Time used'), self.total_time_used) +
cErrores +
cAyudas +
'<tr><td align=right> %s: </td><td> %0.2f" %s</td></tr>' % (_('Time assigned'), ta, txt_more_time) +
'<tr><td align=right> %s: </td><td> %d</td></tr>' % (_('Total moves'), num_moves) +
'<tr><td align=right> %s: </td><td> %0.2f"</td></tr>' % (_('Average time'), tm) +
'<tr><td align=right> %s: </td><td> %s</td></tr>' % (_('Block qualification'), cat_block) +
'<tr><td align=right> %s: </td><td> %s %s</td></tr>' % (_('Level qualification'), cat_level, txt_more_cat) +
'<tr><td align=right> %s: </td><td> %s %s</td></tr>' % (_('Global qualification'), cat_global, txt_more_global) +
'</table></center></big><hr>' +
txt_more_line
)
self.pon_rotulos(None)
QTUtil2.mensaje(self.pantalla, mens, _("Result of training"))
self.total_time_used = 0
else:
if self.tol.go_fast == True or (self.tol.go_fast is None and self.tol.work_level > 0):
self.next_line_run()
return
QTUtil2.mensajeTemporal(self.pantalla, _("This line training is completed."), 1.3)
self.pon_rotulos(0)
self.estado = kFinJuego
self.desactivaTodas()
liOpciones = [k_mainmenu, k_reiniciar, k_configurar, k_utilidades]
if not islast_line:
liOpciones.append(k_siguiente)
self.pantalla.ponToolBar(liOpciones)
def mueveHumano(self, desde, hasta, coronacion=None):
if self.ini_time is None:
self.ini_time = self.base_time
end_time = time.time()
jg = self.checkMueveHumano(desde, hasta, coronacion)
if not jg:
return False
movimiento = jg.movimiento().lower()
if movimiento == self.line.get_move(self.num_move).lower():
self.movimientosPiezas(jg.liMovs)
self.partida.ultPosicion = jg.posicion
self.masJugada(jg, True)
self.error = ""
self.total_time_used += (end_time - self.ini_time)
self.siguienteJugada()
return True
self.errores += 1
self.sigueHumano()
return False
def masJugada(self, jg, siNuestra):
if self.siTerminada():
jg.siJaqueMate = jg.siJaque
jg.siAhogado = not jg.siJaque
self.partida.append_jg(jg)
resp = self.partida.si3repetidas()
if resp:
jg.siTablasRepeticion = True
rotulo = ""
for j in resp:
rotulo += "%d," % (j / 2 + 1,)
rotulo = rotulo.strip(",")
self.rotuloTablasRepeticion = rotulo
if self.partida.ultPosicion.movPeonCap >= 100:
jg.siTablas50 = True
if self.partida.ultPosicion.siFaltaMaterial():
jg.siTablasFaltaMaterial = True
self.ponFlechaSC(jg.desde, jg.hasta)
self.beepExtendido(siNuestra)
self.pgnRefresh(self.partida.ultPosicion.siBlancas)
self.refresh()
self.ponPosicionDGT()
def mueveRival(self, desde, hasta, coronacion):
siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
self.partida.ultPosicion = jg.posicion
self.masJugada(jg, False)
self.movimientosPiezas(jg.liMovs, True)
self.error = ""
def ayuda(self):
self.ayudas += 1
mov = self.line.get_move(self.num_move).lower()
self.tablero.markPosition(mov[:2])
fen = self.partida.ultPosicion.fen()
if fen not in self.dicFENayudas:
self.dicFENayudas[fen] = 1
else:
self.dicFENayudas[fen] += 1
if self.dicFENayudas[fen] > 2:
self.ponFlechaSC(mov[:2], mov[2:4])
def finPartida(self):
self.procesador.inicio()
self.procesador.showTurnOnLigths(self.tol.name)
def finalX(self):
self.procesador.inicio()
return False
def actualPGN(self):
resp = '[Event "%s"]\n' % _("Turn on the lights")
resp += '[Site "%s"]\n' % self.line.label.replace("<br>", " ").strip()
resp += '[FEN "%s"\n' % self.partida.iniPosicion.fen()
resp += "\n" + self.partida.pgnBase()
return resp
|
# -*- coding: utf-8 -*-
import random
import numpy
def createCGraph(n):
Edges = []
Vertices = []
counter = n
while counter > 0:
if Vertices == []:
v0 = vertex('0')
v1 = vertex('1')
e0 = edge(v0,v1)
Vertices.append(v0)
Vertices.append(v1)
Edges.append(e0)
else :
vs = random.choice(Vertices)
ve = random.choice(Vertices)
while ve == vertex('0') :
ve = random.choice(Vertices)
e = edge(vs,ve)
prob = random.randint(0,100)
if vs == ve or e in Edges or prob > 75 :
l = len(Vertices)
name = str(l)
nv = vertex(name)
ne = edge(vs,nv)
Vertices.append(nv)
Edges.append(ne)
else :
Edges.append(e)
counter = counter - 1
k = len(Vertices)
M = numpy.zeros((k,k),dtype = object)
for ed in Edges:
vs = int(ed.startingvertex.name)
ve = int(ed.endingvertex.name)
M[vs,ve] = 1
return Vertices, Edges, M
class vertex:
def __init__(self,name):
self.name = name
def __eq__(self,other):
return self.name == other.name
def __str__(self):
return self.name
def __repr__(self):
return self.name
class edge:
def __init__(self,startingvertex,endingvertex):
self.startingvertex = startingvertex
self.endingvertex = endingvertex
def __eq__(self,other):
return self.startingvertex == other.startingvertex and self.endingvertex == other.endingvertex
def __str__(self):
return self.startingvertex.name+'-->'+self.endingvertex.name
def __repr__(self):
return self.startingvertex.name+'-->'+self.endingvertex.name
|
# Copyright (c) 2013 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import copy
import hashlib
import multiprocessing
import os.path
import re
import signal
import subprocess
import sys
import gyp
import gyp.common
import gyp.msvs_emulation
import gyp.MSVSUtil as MSVSUtil
import gyp.xcode_emulation
from gyp.common import GetEnvironFallback
import gyp.ninja_syntax as ninja_syntax
generator_default_variables = {
'EXECUTABLE_PREFIX': '',
'EXECUTABLE_SUFFIX': '',
'STATIC_LIB_PREFIX': 'lib',
'STATIC_LIB_SUFFIX': '.a',
'SHARED_LIB_PREFIX': 'lib',
# Gyp expects the following variables to be expandable by the build
# system to the appropriate locations. Ninja prefers paths to be
# known at gyp time. To resolve this, introduce special
# variables starting with $! and $| (which begin with a $ so gyp knows it
# should be treated specially, but is otherwise an invalid
# ninja/shell variable) that are passed to gyp here but expanded
# before writing out into the target .ninja files; see
# ExpandSpecial.
# $! is used for variables that represent a path and that can only appear at
# the start of a string, while $| is used for variables that can appear
# anywhere in a string.
'INTERMEDIATE_DIR': '$!INTERMEDIATE_DIR',
'SHARED_INTERMEDIATE_DIR': '$!PRODUCT_DIR/gen',
'PRODUCT_DIR': '$!PRODUCT_DIR',
'CONFIGURATION_NAME': '$|CONFIGURATION_NAME',
# Special variables that may be used by gyp 'rule' targets.
# We generate definitions for these variables on the fly when processing a
# rule.
'RULE_INPUT_ROOT': '${root}',
'RULE_INPUT_DIRNAME': '${dirname}',
'RULE_INPUT_PATH': '${source}',
'RULE_INPUT_EXT': '${ext}',
'RULE_INPUT_NAME': '${name}',
}
# Placates pylint.
generator_additional_non_configuration_keys = []
generator_additional_path_sections = []
generator_extra_sources_for_rules = []
# TODO: figure out how to not build extra host objects in the non-cross-compile
# case when this is enabled, and enable unconditionally.
generator_supports_multiple_toolsets = (
os.environ.get('GYP_CROSSCOMPILE') or
os.environ.get('AR_host') or
os.environ.get('CC_host') or
os.environ.get('CXX_host') or
os.environ.get('AR_target') or
os.environ.get('CC_target') or
os.environ.get('CXX_target'))
def StripPrefix(arg, prefix):
if arg.startswith(prefix):
return arg[len(prefix):]
return arg
def QuoteShellArgument(arg, flavor):
"""Quote a string such that it will be interpreted as a single argument
by the shell."""
# Rather than attempting to enumerate the bad shell characters, just
# whitelist common OK ones and quote anything else.
if re.match(r'^[a-zA-Z0-9_=.\\/-]+$', arg):
return arg # No quoting necessary.
if flavor == 'win':
return gyp.msvs_emulation.QuoteForRspFile(arg)
return "'" + arg.replace("'", "'" + '"\'"' + "'") + "'"
def Define(d, flavor):
"""Takes a preprocessor define and returns a -D parameter that's ninja- and
shell-escaped."""
if flavor == 'win':
# cl.exe replaces literal # characters with = in preprocesor definitions for
# some reason. Octal-encode to work around that.
d = d.replace('#', '\\%03o' % ord('#'))
return QuoteShellArgument(ninja_syntax.escape('-D' + d), flavor)
class Target:
"""Target represents the paths used within a single gyp target.
Conceptually, building a single target A is a series of steps:
1) actions/rules/copies generates source/resources/etc.
2) compiles generates .o files
3) link generates a binary (library/executable)
4) bundle merges the above in a mac bundle
(Any of these steps can be optional.)
From a build ordering perspective, a dependent target B could just
depend on the last output of this series of steps.
But some dependent commands sometimes need to reach inside the box.
For example, when linking B it needs to get the path to the static
library generated by A.
This object stores those paths. To keep things simple, member
variables only store concrete paths to single files, while methods
compute derived values like "the last output of the target".
"""
def __init__(self, type):
# Gyp type ("static_library", etc.) of this target.
self.type = type
# File representing whether any input dependencies necessary for
# dependent actions have completed.
self.preaction_stamp = None
# File representing whether any input dependencies necessary for
# dependent compiles have completed.
self.precompile_stamp = None
# File representing the completion of actions/rules/copies, if any.
self.actions_stamp = None
# Path to the output of the link step, if any.
self.binary = None
# Path to the file representing the completion of building the bundle,
# if any.
self.bundle = None
# On Windows, incremental linking requires linking against all the .objs
# that compose a .lib (rather than the .lib itself). That list is stored
# here.
self.component_objs = None
# Windows only. The import .lib is the output of a build step, but
# because dependents only link against the lib (not both the lib and the
# dll) we keep track of the import library here.
self.import_lib = None
def Linkable(self):
"""Return true if this is a target that can be linked against."""
return self.type in ('static_library', 'shared_library')
def UsesToc(self, flavor):
"""Return true if the target should produce a restat rule based on a TOC
file."""
# For bundles, the .TOC should be produced for the binary, not for
# FinalOutput(). But the naive approach would put the TOC file into the
# bundle, so don't do this for bundles for now.
if flavor == 'win' or self.bundle:
return False
return self.type in ('shared_library', 'loadable_module')
def PreActionInput(self, flavor):
"""Return the path, if any, that should be used as a dependency of
any dependent action step."""
if self.UsesToc(flavor):
return self.FinalOutput() + '.TOC'
return self.FinalOutput() or self.preaction_stamp
def PreCompileInput(self):
"""Return the path, if any, that should be used as a dependency of
any dependent compile step."""
return self.actions_stamp or self.precompile_stamp
def FinalOutput(self):
"""Return the last output of the target, which depends on all prior
steps."""
return self.bundle or self.binary or self.actions_stamp
# A small discourse on paths as used within the Ninja build:
# All files we produce (both at gyp and at build time) appear in the
# build directory (e.g. out/Debug).
#
# Paths within a given .gyp file are always relative to the directory
# containing the .gyp file. Call these "gyp paths". This includes
# sources as well as the starting directory a given gyp rule/action
# expects to be run from. We call the path from the source root to
# the gyp file the "base directory" within the per-.gyp-file
# NinjaWriter code.
#
# All paths as written into the .ninja files are relative to the build
# directory. Call these paths "ninja paths".
#
# We translate between these two notions of paths with two helper
# functions:
#
# - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
# into the equivalent ninja path.
#
# - GypPathToUniqueOutput translates a gyp path into a ninja path to write
# an output file; the result can be namespaced such that it is unique
# to the input file name as well as the output target name.
class NinjaWriter:
def __init__(self, qualified_target, target_outputs, base_dir, build_dir,
output_file, flavor, toplevel_dir=None):
"""
base_dir: path from source root to directory containing this gyp file,
by gyp semantics, all input paths are relative to this
build_dir: path from source root to build output
toplevel_dir: path to the toplevel directory
"""
self.qualified_target = qualified_target
self.target_outputs = target_outputs
self.base_dir = base_dir
self.build_dir = build_dir
self.ninja = ninja_syntax.Writer(output_file)
self.flavor = flavor
self.abs_build_dir = None
if toplevel_dir is not None:
self.abs_build_dir = os.path.abspath(os.path.join(toplevel_dir,
build_dir))
self.obj_ext = '.obj' if flavor == 'win' else '.o'
if flavor == 'win':
# See docstring of msvs_emulation.GenerateEnvironmentFiles().
self.win_env = {}
for arch in ('x86', 'x64'):
self.win_env[arch] = 'environment.' + arch
# Relative path from build output dir to base dir.
build_to_top = gyp.common.InvertRelativePath(build_dir, toplevel_dir)
self.build_to_base = os.path.join(build_to_top, base_dir)
# Relative path from base dir to build dir.
base_to_top = gyp.common.InvertRelativePath(base_dir, toplevel_dir)
self.base_to_build = os.path.join(base_to_top, build_dir)
def ExpandSpecial(self, path, product_dir=None):
"""Expand specials like $!PRODUCT_DIR in |path|.
If |product_dir| is None, assumes the cwd is already the product
dir. Otherwise, |product_dir| is the relative path to the product
dir.
"""
PRODUCT_DIR = '$!PRODUCT_DIR'
if PRODUCT_DIR in path:
if product_dir:
path = path.replace(PRODUCT_DIR, product_dir)
else:
path = path.replace(PRODUCT_DIR + '/', '')
path = path.replace(PRODUCT_DIR + '\\', '')
path = path.replace(PRODUCT_DIR, '.')
INTERMEDIATE_DIR = '$!INTERMEDIATE_DIR'
if INTERMEDIATE_DIR in path:
int_dir = self.GypPathToUniqueOutput('gen')
# GypPathToUniqueOutput generates a path relative to the product dir,
# so insert product_dir in front if it is provided.
path = path.replace(INTERMEDIATE_DIR,
os.path.join(product_dir or '', int_dir))
CONFIGURATION_NAME = '$|CONFIGURATION_NAME'
path = path.replace(CONFIGURATION_NAME, self.config_name)
return path
def ExpandRuleVariables(self, path, root, dirname, source, ext, name):
if self.flavor == 'win':
path = self.msvs_settings.ConvertVSMacros(
path, config=self.config_name)
path = path.replace(generator_default_variables['RULE_INPUT_ROOT'], root)
path = path.replace(generator_default_variables['RULE_INPUT_DIRNAME'],
dirname)
path = path.replace(generator_default_variables['RULE_INPUT_PATH'], source)
path = path.replace(generator_default_variables['RULE_INPUT_EXT'], ext)
path = path.replace(generator_default_variables['RULE_INPUT_NAME'], name)
return path
def GypPathToNinja(self, path, env=None):
"""Translate a gyp path to a ninja path, optionally expanding environment
variable references in |path| with |env|.
See the above discourse on path conversions."""
if env:
if self.flavor == 'mac':
path = gyp.xcode_emulation.ExpandEnvVars(path, env)
elif self.flavor == 'win':
path = gyp.msvs_emulation.ExpandMacros(path, env)
if path.startswith('$!'):
expanded = self.ExpandSpecial(path)
if self.flavor == 'win':
expanded = os.path.normpath(expanded)
return expanded
if '$|' in path:
path = self.ExpandSpecial(path)
assert '$' not in path, path
return os.path.normpath(os.path.join(self.build_to_base, path))
def GypPathToUniqueOutput(self, path, qualified=True):
"""Translate a gyp path to a ninja path for writing output.
If qualified is True, qualify the resulting filename with the name
of the target. This is necessary when e.g. compiling the same
path twice for two separate output targets.
See the above discourse on path conversions."""
path = self.ExpandSpecial(path)
assert not path.startswith('$'), path
# Translate the path following this scheme:
# Input: foo/bar.gyp, target targ, references baz/out.o
# Output: obj/foo/baz/targ.out.o (if qualified)
# obj/foo/baz/out.o (otherwise)
# (and obj.host instead of obj for cross-compiles)
#
# Why this scheme and not some other one?
# 1) for a given input, you can compute all derived outputs by matching
# its path, even if the input is brought via a gyp file with '..'.
# 2) simple files like libraries and stamps have a simple filename.
obj = 'obj'
if self.toolset != 'target':
obj += '.' + self.toolset
path_dir, path_basename = os.path.split(path)
if qualified:
path_basename = self.name + '.' + path_basename
return os.path.normpath(os.path.join(obj, self.base_dir, path_dir,
path_basename))
def WriteCollapsedDependencies(self, name, targets):
"""Given a list of targets, return a path for a single file
representing the result of building all the targets or None.
Uses a stamp file if necessary."""
assert targets == filter(None, targets), targets
if len(targets) == 0:
return None
if len(targets) > 1:
stamp = self.GypPathToUniqueOutput(name + '.stamp')
targets = self.ninja.build(stamp, 'stamp', targets)
self.ninja.newline()
return targets[0]
def WriteSpec(self, spec, config_name, generator_flags,
case_sensitive_filesystem):
"""The main entry point for NinjaWriter: write the build rules for a spec.
Returns a Target object, which represents the output paths for this spec.
Returns None if there are no outputs (e.g. a settings-only 'none' type
target)."""
self.config_name = config_name
self.name = spec['target_name']
self.toolset = spec['toolset']
config = spec['configurations'][config_name]
self.target = Target(spec['type'])
self.is_standalone_static_library = bool(
spec.get('standalone_static_library', 0))
self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
self.xcode_settings = self.msvs_settings = None
if self.flavor == 'mac':
self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
if self.flavor == 'win':
self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec,
generator_flags)
arch = self.msvs_settings.GetArch(config_name)
self.ninja.variable('arch', self.win_env[arch])
self.ninja.variable('cc', '$cl_' + arch)
self.ninja.variable('cxx', '$cl_' + arch)
# Compute predepends for all rules.
# actions_depends is the dependencies this target depends on before running
# any of its action/rule/copy steps.
# compile_depends is the dependencies this target depends on before running
# any of its compile steps.
actions_depends = []
compile_depends = []
# TODO(evan): it is rather confusing which things are lists and which
# are strings. Fix these.
if 'dependencies' in spec:
for dep in spec['dependencies']:
if dep in self.target_outputs:
target = self.target_outputs[dep]
actions_depends.append(target.PreActionInput(self.flavor))
compile_depends.append(target.PreCompileInput())
actions_depends = filter(None, actions_depends)
compile_depends = filter(None, compile_depends)
actions_depends = self.WriteCollapsedDependencies('actions_depends',
actions_depends)
compile_depends = self.WriteCollapsedDependencies('compile_depends',
compile_depends)
self.target.preaction_stamp = actions_depends
self.target.precompile_stamp = compile_depends
# Write out actions, rules, and copies. These must happen before we
# compile any sources, so compute a list of predependencies for sources
# while we do it.
extra_sources = []
mac_bundle_depends = []
self.target.actions_stamp = self.WriteActionsRulesCopies(
spec, extra_sources, actions_depends, mac_bundle_depends)
# If we have actions/rules/copies, we depend directly on those, but
# otherwise we depend on dependent target's actions/rules/copies etc.
# We never need to explicitly depend on previous target's link steps,
# because no compile ever depends on them.
compile_depends_stamp = (self.target.actions_stamp or compile_depends)
# Write out the compilation steps, if any.
link_deps = []
sources = spec.get('sources', []) + extra_sources
if sources:
pch = None
if self.flavor == 'win':
gyp.msvs_emulation.VerifyMissingSources(
sources, self.abs_build_dir, generator_flags, self.GypPathToNinja)
pch = gyp.msvs_emulation.PrecompiledHeader(
self.msvs_settings, config_name, self.GypPathToNinja,
self.GypPathToUniqueOutput, self.obj_ext)
else:
pch = gyp.xcode_emulation.MacPrefixHeader(
self.xcode_settings, self.GypPathToNinja,
lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang))
link_deps = self.WriteSources(
config_name, config, sources, compile_depends_stamp, pch,
case_sensitive_filesystem, spec)
# Some actions/rules output 'sources' that are already object files.
link_deps += [self.GypPathToNinja(f)
for f in sources if f.endswith(self.obj_ext)]
if self.flavor == 'win' and self.target.type == 'static_library':
self.target.component_objs = link_deps
# Write out a link step, if needed.
output = None
if link_deps or self.target.actions_stamp or actions_depends:
output = self.WriteTarget(spec, config_name, config, link_deps,
self.target.actions_stamp or actions_depends)
if self.is_mac_bundle:
mac_bundle_depends.append(output)
# Bundle all of the above together, if needed.
if self.is_mac_bundle:
output = self.WriteMacBundle(spec, mac_bundle_depends)
if not output:
return None
assert self.target.FinalOutput(), output
return self.target
def _WinIdlRule(self, source, prebuild, outputs):
"""Handle the implicit VS .idl rule for one source file. Fills |outputs|
with files that are generated."""
outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
source, self.config_name)
outdir = self.GypPathToNinja(outdir)
def fix_path(path, rel=None):
path = os.path.join(outdir, path)
dirname, basename = os.path.split(source)
root, ext = os.path.splitext(basename)
path = self.ExpandRuleVariables(
path, root, dirname, source, ext, basename)
if rel:
path = os.path.relpath(path, rel)
return path
vars = [(name, fix_path(value, outdir)) for name, value in vars]
output = [fix_path(p) for p in output]
vars.append(('outdir', outdir))
vars.append(('idlflags', flags))
input = self.GypPathToNinja(source)
self.ninja.build(output, 'idl', input,
variables=vars, order_only=prebuild)
outputs.extend(output)
def WriteWinIdlFiles(self, spec, prebuild):
"""Writes rules to match MSVS's implicit idl handling."""
assert self.flavor == 'win'
if self.msvs_settings.HasExplicitIdlRules(spec):
return []
outputs = []
for source in filter(lambda x: x.endswith('.idl'), spec['sources']):
self._WinIdlRule(source, prebuild, outputs)
return outputs
def WriteActionsRulesCopies(self, spec, extra_sources, prebuild,
mac_bundle_depends):
"""Write out the Actions, Rules, and Copies steps. Return a path
representing the outputs of these steps."""
outputs = []
extra_mac_bundle_resources = []
if 'actions' in spec:
outputs += self.WriteActions(spec['actions'], extra_sources, prebuild,
extra_mac_bundle_resources)
if 'rules' in spec:
outputs += self.WriteRules(spec['rules'], extra_sources, prebuild,
extra_mac_bundle_resources)
if 'copies' in spec:
outputs += self.WriteCopies(spec['copies'], prebuild, mac_bundle_depends)
if 'sources' in spec and self.flavor == 'win':
outputs += self.WriteWinIdlFiles(spec, prebuild)
stamp = self.WriteCollapsedDependencies('actions_rules_copies', outputs)
if self.is_mac_bundle:
mac_bundle_resources = spec.get('mac_bundle_resources', []) + \
extra_mac_bundle_resources
self.WriteMacBundleResources(mac_bundle_resources, mac_bundle_depends)
self.WriteMacInfoPlist(mac_bundle_depends)
return stamp
def GenerateDescription(self, verb, message, fallback):
"""Generate and return a description of a build step.
|verb| is the short summary, e.g. ACTION or RULE.
|message| is a hand-written description, or None if not available.
|fallback| is the gyp-level name of the step, usable as a fallback.
"""
if self.toolset != 'target':
verb += '(%s)' % self.toolset
if message:
return '%s %s' % (verb, self.ExpandSpecial(message))
else:
return '%s %s: %s' % (verb, self.name, fallback)
def WriteActions(self, actions, extra_sources, prebuild,
extra_mac_bundle_resources):
# Actions cd into the base directory.
env = self.GetSortedXcodeEnv()
if self.flavor == 'win':
env = self.msvs_settings.GetVSMacroEnv(
'$!PRODUCT_DIR', config=self.config_name)
all_outputs = []
for action in actions:
# First write out a rule for the action.
name = '%s_%s' % (action['action_name'],
hashlib.md5(self.qualified_target).hexdigest())
description = self.GenerateDescription('ACTION',
action.get('message', None),
name)
is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(action)
if self.flavor == 'win' else False)
args = action['action']
rule_name, _ = self.WriteNewNinjaRule(name, args, description,
is_cygwin, env=env)
inputs = [self.GypPathToNinja(i, env) for i in action['inputs']]
if int(action.get('process_outputs_as_sources', False)):
extra_sources += action['outputs']
if int(action.get('process_outputs_as_mac_bundle_resources', False)):
extra_mac_bundle_resources += action['outputs']
outputs = [self.GypPathToNinja(o, env) for o in action['outputs']]
# Then write out an edge using the rule.
self.ninja.build(outputs, rule_name, inputs,
order_only=prebuild)
all_outputs += outputs
self.ninja.newline()
return all_outputs
def WriteRules(self, rules, extra_sources, prebuild,
extra_mac_bundle_resources):
env = self.GetSortedXcodeEnv()
all_outputs = []
for rule in rules:
# First write out a rule for the rule action.
name = '%s_%s' % (rule['rule_name'],
hashlib.md5(self.qualified_target).hexdigest())
# Skip a rule with no action and no inputs.
if 'action' not in rule and not rule.get('rule_sources', []):
continue
args = rule['action']
description = self.GenerateDescription(
'RULE',
rule.get('message', None),
('%s ' + generator_default_variables['RULE_INPUT_PATH']) % name)
is_cygwin = (self.msvs_settings.IsRuleRunUnderCygwin(rule)
if self.flavor == 'win' else False)
rule_name, args = self.WriteNewNinjaRule(
name, args, description, is_cygwin, env=env)
# TODO: if the command references the outputs directly, we should
# simplify it to just use $out.
# Rules can potentially make use of some special variables which
# must vary per source file.
# Compute the list of variables we'll need to provide.
special_locals = ('source', 'root', 'dirname', 'ext', 'name')
needed_variables = set(['source'])
for argument in args:
for var in special_locals:
if ('${%s}' % var) in argument:
needed_variables.add(var)
def cygwin_munge(path):
if is_cygwin:
return path.replace('\\', '/')
return path
# For each source file, write an edge that generates all the outputs.
for source in rule.get('rule_sources', []):
source = os.path.normpath(source)
dirname, basename = os.path.split(source)
root, ext = os.path.splitext(basename)
# Gather the list of inputs and outputs, expanding $vars if possible.
outputs = [self.ExpandRuleVariables(o, root, dirname,
source, ext, basename)
for o in rule['outputs']]
inputs = [self.ExpandRuleVariables(i, root, dirname,
source, ext, basename)
for i in rule.get('inputs', [])]
if int(rule.get('process_outputs_as_sources', False)):
extra_sources += outputs
if int(rule.get('process_outputs_as_mac_bundle_resources', False)):
extra_mac_bundle_resources += outputs
extra_bindings = []
for var in needed_variables:
if var == 'root':
extra_bindings.append(('root', cygwin_munge(root)))
elif var == 'dirname':
# '$dirname' is a parameter to the rule action, which means
# it shouldn't be converted to a Ninja path. But we don't
# want $!PRODUCT_DIR in there either.
dirname_expanded = self.ExpandSpecial(dirname, self.base_to_build)
extra_bindings.append(('dirname', cygwin_munge(dirname_expanded)))
elif var == 'source':
# '$source' is a parameter to the rule action, which means
# it shouldn't be converted to a Ninja path. But we don't
# want $!PRODUCT_DIR in there either.
source_expanded = self.ExpandSpecial(source, self.base_to_build)
extra_bindings.append(('source', cygwin_munge(source_expanded)))
elif var == 'ext':
extra_bindings.append(('ext', ext))
elif var == 'name':
extra_bindings.append(('name', cygwin_munge(basename)))
else:
assert var == None, repr(var)
inputs = [self.GypPathToNinja(i, env) for i in inputs]
outputs = [self.GypPathToNinja(o, env) for o in outputs]
extra_bindings.append(('unique_name',
hashlib.md5(outputs[0]).hexdigest()))
self.ninja.build(outputs, rule_name, self.GypPathToNinja(source),
implicit=inputs,
order_only=prebuild,
variables=extra_bindings)
all_outputs.extend(outputs)
return all_outputs
def WriteCopies(self, copies, prebuild, mac_bundle_depends):
outputs = []
env = self.GetSortedXcodeEnv()
for copy in copies:
for path in copy['files']:
# Normalize the path so trailing slashes don't confuse us.
path = os.path.normpath(path)
basename = os.path.split(path)[1]
src = self.GypPathToNinja(path, env)
dst = self.GypPathToNinja(os.path.join(copy['destination'], basename),
env)
outputs += self.ninja.build(dst, 'copy', src, order_only=prebuild)
if self.is_mac_bundle:
# gyp has mac_bundle_resources to copy things into a bundle's
# Resources folder, but there's no built-in way to copy files to other
# places in the bundle. Hence, some targets use copies for this. Check
# if this file is copied into the current bundle, and if so add it to
# the bundle depends so that dependent targets get rebuilt if the copy
# input changes.
if dst.startswith(self.xcode_settings.GetBundleContentsFolderPath()):
mac_bundle_depends.append(dst)
return outputs
def WriteMacBundleResources(self, resources, bundle_depends):
"""Writes ninja edges for 'mac_bundle_resources'."""
for output, res in gyp.xcode_emulation.GetMacBundleResources(
generator_default_variables['PRODUCT_DIR'],
self.xcode_settings, map(self.GypPathToNinja, resources)):
output = self.ExpandSpecial(output)
self.ninja.build(output, 'mac_tool', res,
variables=[('mactool_cmd', 'copy-bundle-resource')])
bundle_depends.append(output)
def WriteMacInfoPlist(self, bundle_depends):
"""Write build rules for bundle Info.plist files."""
info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
generator_default_variables['PRODUCT_DIR'],
self.xcode_settings, self.GypPathToNinja)
if not info_plist:
return
out = self.ExpandSpecial(out)
if defines:
# Create an intermediate file to store preprocessed results.
intermediate_plist = self.GypPathToUniqueOutput(
os.path.basename(info_plist))
defines = ' '.join([Define(d, self.flavor) for d in defines])
info_plist = self.ninja.build(intermediate_plist, 'infoplist', info_plist,
variables=[('defines',defines)])
env = self.GetSortedXcodeEnv(additional_settings=extra_env)
env = self.ComputeExportEnvString(env)
self.ninja.build(out, 'mac_tool', info_plist,
variables=[('mactool_cmd', 'copy-info-plist'),
('env', env)])
bundle_depends.append(out)
def WriteSources(self, config_name, config, sources, predepends,
precompiled_header, case_sensitive_filesystem, spec):
"""Write build rules to compile all of |sources|."""
if self.toolset == 'host':
self.ninja.variable('ar', '$ar_host')
self.ninja.variable('cc', '$cc_host')
self.ninja.variable('cxx', '$cxx_host')
self.ninja.variable('ld', '$ld_host')
extra_defines = []
if self.flavor == 'mac':
cflags = self.xcode_settings.GetCflags(config_name)
cflags_c = self.xcode_settings.GetCflagsC(config_name)
cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
cflags_objc = ['$cflags_c'] + \
self.xcode_settings.GetCflagsObjC(config_name)
cflags_objcc = ['$cflags_cc'] + \
self.xcode_settings.GetCflagsObjCC(config_name)
elif self.flavor == 'win':
cflags = self.msvs_settings.GetCflags(config_name)
cflags_c = self.msvs_settings.GetCflagsC(config_name)
cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
extra_defines = self.msvs_settings.GetComputedDefines(config_name)
pdbpath = self.msvs_settings.GetCompilerPdbName(
config_name, self.ExpandSpecial)
if not pdbpath:
obj = 'obj'
if self.toolset != 'target':
obj += '.' + self.toolset
pdbpath = os.path.normpath(os.path.join(obj, self.base_dir,
self.name + '.pdb'))
self.WriteVariableList('pdbname', [pdbpath])
self.WriteVariableList('pchprefix', [self.name])
else:
cflags = config.get('cflags', [])
cflags_c = config.get('cflags_c', [])
cflags_cc = config.get('cflags_cc', [])
defines = config.get('defines', []) + extra_defines
self.WriteVariableList('defines', [Define(d, self.flavor) for d in defines])
if self.flavor == 'win':
self.WriteVariableList('rcflags',
[QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
for f in self.msvs_settings.GetRcflags(config_name,
self.GypPathToNinja)])
include_dirs = config.get('include_dirs', [])
if self.flavor == 'win':
include_dirs = self.msvs_settings.AdjustIncludeDirs(include_dirs,
config_name)
env = self.GetSortedXcodeEnv()
self.WriteVariableList('includes',
[QuoteShellArgument('-I' + self.GypPathToNinja(i, env), self.flavor)
for i in include_dirs])
pch_commands = precompiled_header.GetPchBuildCommands()
if self.flavor == 'mac':
# Most targets use no precompiled headers, so only write these if needed.
for ext, var in [('c', 'cflags_pch_c'), ('cc', 'cflags_pch_cc'),
('m', 'cflags_pch_objc'), ('mm', 'cflags_pch_objcc')]:
include = precompiled_header.GetInclude(ext)
if include: self.ninja.variable(var, include)
self.WriteVariableList('cflags', map(self.ExpandSpecial, cflags))
self.WriteVariableList('cflags_c', map(self.ExpandSpecial, cflags_c))
self.WriteVariableList('cflags_cc', map(self.ExpandSpecial, cflags_cc))
if self.flavor == 'mac':
self.WriteVariableList('cflags_objc', map(self.ExpandSpecial,
cflags_objc))
self.WriteVariableList('cflags_objcc', map(self.ExpandSpecial,
cflags_objcc))
self.ninja.newline()
outputs = []
for source in sources:
filename, ext = os.path.splitext(source)
ext = ext[1:]
obj_ext = self.obj_ext
if ext in ('cc', 'cpp', 'cxx'):
command = 'cxx'
elif ext == 'c' or (ext == 'S' and self.flavor != 'win'):
command = 'cc'
elif ext == 's' and self.flavor != 'win': # Doesn't generate .o.d files.
command = 'cc_s'
elif (self.flavor == 'win' and ext == 'asm' and
self.msvs_settings.GetArch(config_name) == 'x86' and
not self.msvs_settings.HasExplicitAsmRules(spec)):
# Asm files only get auto assembled for x86 (not x64).
command = 'asm'
# Add the _asm suffix as msvs is capable of handling .cc and
# .asm files of the same name without collision.
obj_ext = '_asm.obj'
elif self.flavor == 'mac' and ext == 'm':
command = 'objc'
elif self.flavor == 'mac' and ext == 'mm':
command = 'objcxx'
elif self.flavor == 'win' and ext == 'rc':
command = 'rc'
obj_ext = '.res'
else:
# Ignore unhandled extensions.
continue
input = self.GypPathToNinja(source)
output = self.GypPathToUniqueOutput(filename + obj_ext)
# Ninja's depfile handling gets confused when the case of a filename
# changes on a case-insensitive file system. To work around that, always
# convert .o filenames to lowercase on such file systems. See
# https://github.com/martine/ninja/issues/402 for details.
if not case_sensitive_filesystem:
output = output.lower()
implicit = precompiled_header.GetObjDependencies([input], [output])
variables = []
if self.flavor == 'win':
variables, output, implicit = precompiled_header.GetFlagsModifications(
input, output, implicit, command, cflags_c, cflags_cc,
self.ExpandSpecial)
self.ninja.build(output, command, input,
implicit=[gch for _, _, gch in implicit],
order_only=predepends, variables=variables)
outputs.append(output)
self.WritePchTargets(pch_commands)
self.ninja.newline()
return outputs
def WritePchTargets(self, pch_commands):
"""Writes ninja rules to compile prefix headers."""
if not pch_commands:
return
for gch, lang_flag, lang, input in pch_commands:
var_name = {
'c': 'cflags_pch_c',
'cc': 'cflags_pch_cc',
'm': 'cflags_pch_objc',
'mm': 'cflags_pch_objcc',
}[lang]
map = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }
cmd = map.get(lang)
self.ninja.build(gch, cmd, input, variables=[(var_name, lang_flag)])
def WriteLink(self, spec, config_name, config, link_deps):
"""Write out a link step. Fills out target.binary. """
command = {
'executable': 'link',
'loadable_module': 'solink_module',
'shared_library': 'solink',
}[spec['type']]
command_suffix = ''
implicit_deps = set()
solibs = set()
if 'dependencies' in spec:
# Two kinds of dependencies:
# - Linkable dependencies (like a .a or a .so): add them to the link line.
# - Non-linkable dependencies (like a rule that generates a file
# and writes a stamp file): add them to implicit_deps
extra_link_deps = set()
for dep in spec['dependencies']:
target = self.target_outputs.get(dep)
if not target:
continue
linkable = target.Linkable()
if linkable:
if (self.flavor == 'win' and
target.component_objs and
self.msvs_settings.IsUseLibraryDependencyInputs(config_name)):
extra_link_deps |= set(target.component_objs)
elif self.flavor == 'win' and target.import_lib:
extra_link_deps.add(target.import_lib)
elif target.UsesToc(self.flavor):
solibs.add(target.binary)
implicit_deps.add(target.binary + '.TOC')
else:
extra_link_deps.add(target.binary)
final_output = target.FinalOutput()
if not linkable or final_output != target.binary:
implicit_deps.add(final_output)
link_deps.extend(list(extra_link_deps))
extra_bindings = []
if self.is_mac_bundle:
output = self.ComputeMacBundleBinaryOutput()
else:
output = self.ComputeOutput(spec)
extra_bindings.append(('postbuilds',
self.GetPostbuildCommand(spec, output, output)))
is_executable = spec['type'] == 'executable'
if self.flavor == 'mac':
ldflags = self.xcode_settings.GetLdflags(config_name,
self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
self.GypPathToNinja)
elif self.flavor == 'win':
manifest_name = self.GypPathToUniqueOutput(
self.ComputeOutputFileName(spec))
ldflags, manifest_files = self.msvs_settings.GetLdflags(config_name,
self.GypPathToNinja, self.ExpandSpecial, manifest_name, is_executable)
self.WriteVariableList('manifests', manifest_files)
command_suffix = _GetWinLinkRuleNameSuffix(
self.msvs_settings.IsEmbedManifest(config_name),
self.msvs_settings.IsLinkIncremental(config_name))
def_file = self.msvs_settings.GetDefFile(self.GypPathToNinja)
if def_file:
implicit_deps.add(def_file)
else:
ldflags = config.get('ldflags', [])
if is_executable and len(solibs):
rpath = 'lib/'
if self.toolset != 'target':
rpath += self.toolset
ldflags.append('-Wl,-rpath=\$$ORIGIN/%s' % rpath)
ldflags.append('-Wl,-rpath-link=%s' % rpath)
self.WriteVariableList('ldflags',
gyp.common.uniquer(map(self.ExpandSpecial,
ldflags)))
library_dirs = config.get('library_dirs', [])
if self.flavor == 'win':
library_dirs = [self.msvs_settings.ConvertVSMacros(l, config_name)
for l in library_dirs]
library_dirs = [QuoteShellArgument('-LIBPATH:' + self.GypPathToNinja(l),
self.flavor)
for l in library_dirs]
else:
library_dirs = [QuoteShellArgument('-L' + self.GypPathToNinja(l),
self.flavor)
for l in library_dirs]
libraries = gyp.common.uniquer(map(self.ExpandSpecial,
spec.get('libraries', [])))
if self.flavor == 'mac':
libraries = self.xcode_settings.AdjustLibraries(libraries)
elif self.flavor == 'win':
libraries = self.msvs_settings.AdjustLibraries(libraries)
self.WriteVariableList('libs', library_dirs + libraries)
self.target.binary = output
if command in ('solink', 'solink_module'):
extra_bindings.append(('soname', os.path.split(output)[1]))
extra_bindings.append(('lib',
gyp.common.EncodePOSIXShellArgument(output)))
if self.flavor == 'win':
extra_bindings.append(('dll', output))
if '/NOENTRY' not in ldflags:
self.target.import_lib = output + '.lib'
extra_bindings.append(('implibflag',
'/IMPLIB:%s' % self.target.import_lib))
output = [output, self.target.import_lib]
else:
output = [output, output + '.TOC']
if len(solibs):
extra_bindings.append(('solibs', gyp.common.EncodePOSIXShellList(solibs)))
self.ninja.build(output, command + command_suffix, link_deps,
implicit=list(implicit_deps),
variables=extra_bindings)
def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
if spec['type'] == 'none':
# TODO(evan): don't call this function for 'none' target types, as
# it doesn't do anything, and we fake out a 'binary' with a stamp file.
self.target.binary = compile_deps
elif spec['type'] == 'static_library':
self.target.binary = self.ComputeOutput(spec)
variables = []
postbuild = self.GetPostbuildCommand(
spec, self.target.binary, self.target.binary)
if postbuild:
variables.append(('postbuilds', postbuild))
if self.xcode_settings:
libtool_flags = self.xcode_settings.GetLibtoolflags(config_name)
if libtool_flags:
variables.append(('libtool_flags', libtool_flags))
if (self.flavor not in ('mac', 'openbsd', 'win') and not
self.is_standalone_static_library):
self.ninja.build(self.target.binary, 'alink_thin', link_deps,
order_only=compile_deps, variables=variables)
else:
if self.msvs_settings:
libflags = self.msvs_settings.GetLibFlags(config_name,
self.GypPathToNinja)
variables.append(('libflags', libflags))
self.ninja.build(self.target.binary, 'alink', link_deps,
order_only=compile_deps, variables=variables)
else:
self.WriteLink(spec, config_name, config, link_deps)
return self.target.binary
def WriteMacBundle(self, spec, mac_bundle_depends):
assert self.is_mac_bundle
package_framework = spec['type'] in ('shared_library', 'loadable_module')
output = self.ComputeMacBundleOutput()
postbuild = self.GetPostbuildCommand(spec, output, self.target.binary,
is_command_start=not package_framework)
variables = []
if postbuild:
variables.append(('postbuilds', postbuild))
if package_framework:
variables.append(('version', self.xcode_settings.GetFrameworkVersion()))
self.ninja.build(output, 'package_framework', mac_bundle_depends,
variables=variables)
else:
self.ninja.build(output, 'stamp', mac_bundle_depends,
variables=variables)
self.target.bundle = output
return output
def GetSortedXcodeEnv(self, additional_settings=None):
"""Returns the variables Xcode would set for build steps."""
assert self.abs_build_dir
abs_build_dir = self.abs_build_dir
return gyp.xcode_emulation.GetSortedXcodeEnv(
self.xcode_settings, abs_build_dir,
os.path.join(abs_build_dir, self.build_to_base), self.config_name,
additional_settings)
def GetSortedXcodePostbuildEnv(self):
"""Returns the variables Xcode would set for postbuild steps."""
postbuild_settings = {}
# CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
# TODO(thakis): It would be nice to have some general mechanism instead.
strip_save_file = self.xcode_settings.GetPerTargetSetting(
'CHROMIUM_STRIP_SAVE_FILE')
if strip_save_file:
postbuild_settings['CHROMIUM_STRIP_SAVE_FILE'] = strip_save_file
return self.GetSortedXcodeEnv(additional_settings=postbuild_settings)
def GetPostbuildCommand(self, spec, output, output_binary,
is_command_start=False):
"""Returns a shell command that runs all the postbuilds, and removes
|output| if any of them fails. If |is_command_start| is False, then the
returned string will start with ' && '."""
if not self.xcode_settings or spec['type'] == 'none' or not output:
return ''
output = QuoteShellArgument(output, self.flavor)
target_postbuilds = []
if output_binary is not None:
target_postbuilds = self.xcode_settings.GetTargetPostbuilds(
self.config_name,
os.path.normpath(os.path.join(self.base_to_build, output)),
QuoteShellArgument(
os.path.normpath(os.path.join(self.base_to_build, output_binary)),
self.flavor),
quiet=True)
postbuilds = gyp.xcode_emulation.GetSpecPostbuildCommands(spec, quiet=True)
postbuilds = target_postbuilds + postbuilds
if not postbuilds:
return ''
# Postbuilds expect to be run in the gyp file's directory, so insert an
# implicit postbuild to cd to there.
postbuilds.insert(0, gyp.common.EncodePOSIXShellList(
['cd', self.build_to_base]))
env = self.ComputeExportEnvString(self.GetSortedXcodePostbuildEnv())
# G will be non-null if any postbuild fails. Run all postbuilds in a
# subshell.
commands = env + ' (' + \
' && '.join([ninja_syntax.escape(command) for command in postbuilds])
command_string = (commands + '); G=$$?; '
# Remove the final output if any postbuild failed.
'((exit $$G) || rm -rf %s) ' % output + '&& exit $$G)')
if is_command_start:
return '(' + command_string + ' && '
else:
return '$ && (' + command_string
def ComputeExportEnvString(self, env):
"""Given an environment, returns a string looking like
'export FOO=foo; export BAR="${FOO} bar;'
that exports |env| to the shell."""
export_str = []
for k, v in env:
export_str.append('export %s=%s;' %
(k, ninja_syntax.escape(gyp.common.EncodePOSIXShellArgument(v))))
return ' '.join(export_str)
def ComputeMacBundleOutput(self):
"""Return the 'output' (full output path) to a bundle output directory."""
assert self.is_mac_bundle
path = generator_default_variables['PRODUCT_DIR']
return self.ExpandSpecial(
os.path.join(path, self.xcode_settings.GetWrapperName()))
def ComputeMacBundleBinaryOutput(self):
"""Return the 'output' (full output path) to the binary in a bundle."""
assert self.is_mac_bundle
path = generator_default_variables['PRODUCT_DIR']
return self.ExpandSpecial(
os.path.join(path, self.xcode_settings.GetExecutablePath()))
def ComputeOutputFileName(self, spec, type=None):
"""Compute the filename of the final output for the current target."""
if not type:
type = spec['type']
default_variables = copy.copy(generator_default_variables)
CalculateVariables(default_variables, {'flavor': self.flavor})
# Compute filename prefix: the product prefix, or a default for
# the product type.
DEFAULT_PREFIX = {
'loadable_module': default_variables['SHARED_LIB_PREFIX'],
'shared_library': default_variables['SHARED_LIB_PREFIX'],
'static_library': default_variables['STATIC_LIB_PREFIX'],
'executable': default_variables['EXECUTABLE_PREFIX'],
}
prefix = spec.get('product_prefix', DEFAULT_PREFIX.get(type, ''))
# Compute filename extension: the product extension, or a default
# for the product type.
DEFAULT_EXTENSION = {
'loadable_module': default_variables['SHARED_LIB_SUFFIX'],
'shared_library': default_variables['SHARED_LIB_SUFFIX'],
'static_library': default_variables['STATIC_LIB_SUFFIX'],
'executable': default_variables['EXECUTABLE_SUFFIX'],
}
extension = spec.get('product_extension')
if extension:
extension = '.' + extension
else:
extension = DEFAULT_EXTENSION.get(type, '')
if 'product_name' in spec:
# If we were given an explicit name, use that.
target = spec['product_name']
else:
# Otherwise, derive a name from the target name.
target = spec['target_name']
if prefix == 'lib':
# Snip out an extra 'lib' from libs if appropriate.
target = StripPrefix(target, 'lib')
if type in ('static_library', 'loadable_module', 'shared_library',
'executable'):
return '%s%s%s' % (prefix, target, extension)
elif type == 'none':
return '%s.stamp' % target
else:
raise Exception('Unhandled output type %s' % type)
def ComputeOutput(self, spec, type=None):
"""Compute the path for the final output of the spec."""
assert not self.is_mac_bundle or type
if not type:
type = spec['type']
if self.flavor == 'win':
override = self.msvs_settings.GetOutputName(self.config_name,
self.ExpandSpecial)
if override:
return override
if self.flavor == 'mac' and type in (
'static_library', 'executable', 'shared_library', 'loadable_module'):
filename = self.xcode_settings.GetExecutablePath()
else:
filename = self.ComputeOutputFileName(spec, type)
if 'product_dir' in spec:
path = os.path.join(spec['product_dir'], filename)
return self.ExpandSpecial(path)
# Some products go into the output root, libraries go into shared library
# dir, and everything else goes into the normal place.
type_in_output_root = ['executable', 'loadable_module']
if self.flavor == 'mac' and self.toolset == 'target':
type_in_output_root += ['shared_library', 'static_library']
elif self.flavor == 'win' and self.toolset == 'target':
type_in_output_root += ['shared_library']
if type in type_in_output_root or self.is_standalone_static_library:
return filename
elif type == 'shared_library':
libdir = 'lib'
if self.toolset != 'target':
libdir = os.path.join('lib', '%s' % self.toolset)
return os.path.join(libdir, filename)
else:
return self.GypPathToUniqueOutput(filename, qualified=False)
def WriteVariableList(self, var, values):
assert not isinstance(values, str)
if values is None:
values = []
self.ninja.variable(var, ' '.join(values))
def WriteNewNinjaRule(self, name, args, description, is_cygwin, env):
"""Write out a new ninja "rule" statement for a given command.
Returns the name of the new rule, and a copy of |args| with variables
expanded."""
if self.flavor == 'win':
args = [self.msvs_settings.ConvertVSMacros(
arg, self.base_to_build, config=self.config_name)
for arg in args]
description = self.msvs_settings.ConvertVSMacros(
description, config=self.config_name)
elif self.flavor == 'mac':
# |env| is an empty list on non-mac.
args = [gyp.xcode_emulation.ExpandEnvVars(arg, env) for arg in args]
description = gyp.xcode_emulation.ExpandEnvVars(description, env)
# TODO: we shouldn't need to qualify names; we do it because
# currently the ninja rule namespace is global, but it really
# should be scoped to the subninja.
rule_name = self.name
if self.toolset == 'target':
rule_name += '.' + self.toolset
rule_name += '.' + name
rule_name = re.sub('[^a-zA-Z0-9_]', '_', rule_name)
# Remove variable references, but not if they refer to the magic rule
# variables. This is not quite right, as it also protects these for
# actions, not just for rules where they are valid. Good enough.
protect = [ '${root}', '${dirname}', '${source}', '${ext}', '${name}' ]
protect = '(?!' + '|'.join(map(re.escape, protect)) + ')'
description = re.sub(protect + r'\$', '_', description)
# gyp dictates that commands are run from the base directory.
# cd into the directory before running, and adjust paths in
# the arguments to point to the proper locations.
rspfile = None
rspfile_content = None
args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
if self.flavor == 'win':
rspfile = rule_name + '.$unique_name.rsp'
# The cygwin case handles this inside the bash sub-shell.
run_in = '' if is_cygwin else ' ' + self.build_to_base
if is_cygwin:
rspfile_content = self.msvs_settings.BuildCygwinBashCommandLine(
args, self.build_to_base)
else:
rspfile_content = gyp.msvs_emulation.EncodeRspFileList(args)
command = ('%s gyp-win-tool action-wrapper $arch ' % sys.executable +
rspfile + run_in)
else:
env = self.ComputeExportEnvString(env)
command = gyp.common.EncodePOSIXShellList(args)
command = 'cd %s; ' % self.build_to_base + env + command
# GYP rules/actions express being no-ops by not touching their outputs.
# Avoid executing downstream dependencies in this case by specifying
# restat=1 to ninja.
self.ninja.rule(rule_name, command, description, restat=True,
rspfile=rspfile, rspfile_content=rspfile_content)
self.ninja.newline()
return rule_name, args
def CalculateVariables(default_variables, params):
"""Calculate additional variables for use in the build (called by gyp)."""
global generator_additional_non_configuration_keys
global generator_additional_path_sections
flavor = gyp.common.GetFlavor(params)
if flavor == 'mac':
default_variables.setdefault('OS', 'mac')
default_variables.setdefault('SHARED_LIB_SUFFIX', '.dylib')
default_variables.setdefault('SHARED_LIB_DIR',
generator_default_variables['PRODUCT_DIR'])
default_variables.setdefault('LIB_DIR',
generator_default_variables['PRODUCT_DIR'])
# Copy additional generator configuration data from Xcode, which is shared
# by the Mac Ninja generator.
import gyp.generator.xcode as xcode_generator
generator_additional_non_configuration_keys = getattr(xcode_generator,
'generator_additional_non_configuration_keys', [])
generator_additional_path_sections = getattr(xcode_generator,
'generator_additional_path_sections', [])
global generator_extra_sources_for_rules
generator_extra_sources_for_rules = getattr(xcode_generator,
'generator_extra_sources_for_rules', [])
elif flavor == 'win':
default_variables.setdefault('OS', 'win')
default_variables['EXECUTABLE_SUFFIX'] = '.exe'
default_variables['STATIC_LIB_PREFIX'] = ''
default_variables['STATIC_LIB_SUFFIX'] = '.lib'
default_variables['SHARED_LIB_PREFIX'] = ''
default_variables['SHARED_LIB_SUFFIX'] = '.dll'
generator_flags = params.get('generator_flags', {})
# Copy additional generator configuration data from VS, which is shared
# by the Windows Ninja generator.
import gyp.generator.msvs as msvs_generator
generator_additional_non_configuration_keys = getattr(msvs_generator,
'generator_additional_non_configuration_keys', [])
generator_additional_path_sections = getattr(msvs_generator,
'generator_additional_path_sections', [])
# Set a variable so conditions can be based on msvs_version.
msvs_version = gyp.msvs_emulation.GetVSVersion(generator_flags)
default_variables['MSVS_VERSION'] = msvs_version.ShortName()
# To determine processor word size on Windows, in addition to checking
# PROCESSOR_ARCHITECTURE (which reflects the word size of the current
# process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
# contains the actual word size of the system when running thru WOW64).
if ('64' in os.environ.get('PROCESSOR_ARCHITECTURE', '') or
'64' in os.environ.get('PROCESSOR_ARCHITEW6432', '')):
default_variables['MSVS_OS_BITS'] = 64
else:
default_variables['MSVS_OS_BITS'] = 32
else:
operating_system = flavor
if flavor == 'android':
operating_system = 'linux' # Keep this legacy behavior for now.
default_variables.setdefault('OS', operating_system)
default_variables.setdefault('SHARED_LIB_SUFFIX', '.so')
default_variables.setdefault('SHARED_LIB_DIR',
os.path.join('$!PRODUCT_DIR', 'lib'))
default_variables.setdefault('LIB_DIR',
os.path.join('$!PRODUCT_DIR', 'obj'))
def OpenOutput(path, mode='w'):
"""Open |path| for writing, creating directories if necessary."""
try:
os.makedirs(os.path.dirname(path))
except OSError:
pass
return open(path, mode)
def CommandWithWrapper(cmd, wrappers, prog):
wrapper = wrappers.get(cmd, '')
if wrapper:
return wrapper + ' ' + prog
return prog
def GetDefaultConcurrentLinks():
"""Returns a best-guess for a number of concurrent links."""
if sys.platform in ('win32', 'cygwin'):
import ctypes
class MEMORYSTATUSEX(ctypes.Structure):
_fields_ = [
("dwLength", ctypes.c_ulong),
("dwMemoryLoad", ctypes.c_ulong),
("ullTotalPhys", ctypes.c_ulonglong),
("ullAvailPhys", ctypes.c_ulonglong),
("ullTotalPageFile", ctypes.c_ulonglong),
("ullAvailPageFile", ctypes.c_ulonglong),
("ullTotalVirtual", ctypes.c_ulonglong),
("ullAvailVirtual", ctypes.c_ulonglong),
("sullAvailExtendedVirtual", ctypes.c_ulonglong),
]
stat = MEMORYSTATUSEX()
stat.dwLength = ctypes.sizeof(stat)
ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
return max(1, stat.ullTotalPhys / (4 * (2 ** 30))) # total / 4GB
else:
# TODO(scottmg): Implement this for other platforms.
return 1
def _GetWinLinkRuleNameSuffix(embed_manifest, link_incremental):
"""Returns the suffix used to select an appropriate linking rule depending on
whether the manifest embedding and/or incremental linking is enabled."""
suffix = ''
if embed_manifest:
suffix += '_embed'
if link_incremental:
suffix += '_inc'
return suffix
def _AddWinLinkRules(master_ninja, embed_manifest, link_incremental):
"""Adds link rules for Windows platform to |master_ninja|."""
def FullLinkCommand(ldcmd, out, binary_type):
cmd = ('cmd /c %(ldcmd)s'
' && %(python)s gyp-win-tool manifest-wrapper $arch'
' cmd /c if exist %(out)s.manifest del %(out)s.manifest'
' && %(python)s gyp-win-tool manifest-wrapper $arch'
' $mt -nologo -manifest $manifests')
if embed_manifest and not link_incremental:
# Embed manifest into a binary. If incremental linking is enabled,
# embedding is postponed to the re-linking stage (see below).
cmd += ' -outputresource:%(out)s;%(resname)s'
else:
# Save manifest as an external file.
cmd += ' -out:%(out)s.manifest'
if link_incremental:
# There is no point in generating separate rule for the case when
# incremental linking is enabled, but manifest embedding is disabled.
# In that case the basic rule should be used (e.g. 'link').
# See also implementation of _GetWinLinkRuleNameSuffix().
assert embed_manifest
# Make .rc file out of manifest, compile it to .res file and re-link.
cmd += (' && %(python)s gyp-win-tool manifest-to-rc $arch'
' %(out)s.manifest %(out)s.manifest.rc %(resname)s'
' && %(python)s gyp-win-tool rc-wrapper $arch $rc'
' %(out)s.manifest.rc'
' && %(ldcmd)s %(out)s.manifest.res')
resource_name = {
'exe': '1',
'dll': '2',
}[binary_type]
return cmd % {'python': sys.executable,
'out': out,
'ldcmd': ldcmd,
'resname': resource_name}
rule_name_suffix = _GetWinLinkRuleNameSuffix(embed_manifest, link_incremental)
dlldesc = 'LINK%s(DLL) $dll' % rule_name_suffix.upper()
dllcmd = ('%s gyp-win-tool link-wrapper $arch '
'$ld /nologo $implibflag /DLL /OUT:$dll '
'/PDB:$dll.pdb @$dll.rsp' % sys.executable)
dllcmd = FullLinkCommand(dllcmd, '$dll', 'dll')
master_ninja.rule('solink' + rule_name_suffix,
description=dlldesc, command=dllcmd,
rspfile='$dll.rsp',
rspfile_content='$libs $in_newline $ldflags',
restat=True)
master_ninja.rule('solink_module' + rule_name_suffix,
description=dlldesc, command=dllcmd,
rspfile='$dll.rsp',
rspfile_content='$libs $in_newline $ldflags',
restat=True)
# Note that ldflags goes at the end so that it has the option of
# overriding default settings earlier in the command line.
exe_cmd = ('%s gyp-win-tool link-wrapper $arch '
'$ld /nologo /OUT:$out /PDB:$out.pdb @$out.rsp' %
sys.executable)
exe_cmd = FullLinkCommand(exe_cmd, '$out', 'exe')
master_ninja.rule('link' + rule_name_suffix,
description='LINK%s $out' % rule_name_suffix.upper(),
command=exe_cmd,
rspfile='$out.rsp',
rspfile_content='$in_newline $libs $ldflags')
def GenerateOutputForConfig(target_list, target_dicts, data, params,
config_name):
options = params['options']
flavor = gyp.common.GetFlavor(params)
generator_flags = params.get('generator_flags', {})
# generator_dir: relative path from pwd to where make puts build files.
# Makes migrating from make to ninja easier, ninja doesn't put anything here.
generator_dir = os.path.relpath(params['options'].generator_output or '.')
# output_dir: relative path from generator_dir to the build directory.
output_dir = generator_flags.get('output_dir', 'out')
# build_dir: relative path from source root to our output files.
# e.g. "out/Debug"
build_dir = os.path.normpath(os.path.join(generator_dir,
output_dir,
config_name))
toplevel_build = os.path.join(options.toplevel_dir, build_dir)
master_ninja = ninja_syntax.Writer(
OpenOutput(os.path.join(toplevel_build, 'build.ninja')),
width=120)
case_sensitive_filesystem = not os.path.exists(
os.path.join(toplevel_build, 'BUILD.NINJA'))
# Put build-time support tools in out/{config_name}.
gyp.common.CopyTool(flavor, toplevel_build)
# Grab make settings for CC/CXX.
# The rules are
# - The priority from low to high is gcc/g++, the 'make_global_settings' in
# gyp, the environment variable.
# - If there is no 'make_global_settings' for CC.host/CXX.host or
# 'CC_host'/'CXX_host' enviroment variable, cc_host/cxx_host should be set
# to cc/cxx.
if flavor == 'win':
# Overridden by local arch choice in the use_deps case.
# Chromium's ffmpeg c99conv.py currently looks for a 'cc =' line in
# build.ninja so needs something valid here. http://crbug.com/233985
cc = 'cl.exe'
cxx = 'cl.exe'
ld = 'link.exe'
ld_host = '$ld'
else:
cc = 'gcc'
cxx = 'g++'
ld = '$cxx'
ld_host = '$cxx_host'
cc_host = None
cxx_host = None
cc_host_global_setting = None
cxx_host_global_setting = None
build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
make_global_settings = data[build_file].get('make_global_settings', [])
build_to_root = gyp.common.InvertRelativePath(build_dir,
options.toplevel_dir)
wrappers = {}
for key, value in make_global_settings:
if key == 'CC':
cc = os.path.join(build_to_root, value)
if key == 'CXX':
cxx = os.path.join(build_to_root, value)
if key == 'LD':
ld = os.path.join(build_to_root, value)
if key == 'CC.host':
cc_host = os.path.join(build_to_root, value)
cc_host_global_setting = value
if key == 'CXX.host':
cxx_host = os.path.join(build_to_root, value)
cxx_host_global_setting = value
if key == 'LD.host':
ld_host = os.path.join(build_to_root, value)
if key.endswith('_wrapper'):
wrappers[key[:-len('_wrapper')]] = os.path.join(build_to_root, value)
# Support wrappers from environment variables too.
for key, value in os.environ.iteritems():
if key.lower().endswith('_wrapper'):
key_prefix = key[:-len('_wrapper')]
key_prefix = re.sub(r'\.HOST$', '.host', key_prefix)
wrappers[key_prefix] = os.path.join(build_to_root, value)
if flavor == 'win':
cl_paths = gyp.msvs_emulation.GenerateEnvironmentFiles(
toplevel_build, generator_flags, OpenOutput)
for arch, path in cl_paths.iteritems():
master_ninja.variable(
'cl_' + arch, CommandWithWrapper('CC', wrappers,
QuoteShellArgument(path, flavor)))
cc = GetEnvironFallback(['CC_target', 'CC'], cc)
master_ninja.variable('cc', CommandWithWrapper('CC', wrappers, cc))
cxx = GetEnvironFallback(['CXX_target', 'CXX'], cxx)
master_ninja.variable('cxx', CommandWithWrapper('CXX', wrappers, cxx))
ld = GetEnvironFallback(['LD_target', 'LD'], ld)
if flavor == 'win':
master_ninja.variable('ld', ld)
master_ninja.variable('idl', 'midl.exe')
master_ninja.variable('ar', 'lib.exe')
master_ninja.variable('rc', 'rc.exe')
master_ninja.variable('asm', 'ml.exe')
master_ninja.variable('mt', 'mt.exe')
else:
master_ninja.variable('ld', CommandWithWrapper('LINK', wrappers, ld))
master_ninja.variable('ar', GetEnvironFallback(['AR_target', 'AR'], 'ar'))
if generator_supports_multiple_toolsets:
if not cc_host:
cc_host = cc
if not cxx_host:
cxx_host = cxx
master_ninja.variable('ar_host', GetEnvironFallback(['AR_host'], 'ar'))
cc_host = GetEnvironFallback(['CC_host'], cc_host)
cxx_host = GetEnvironFallback(['CXX_host'], cxx_host)
ld_host = GetEnvironFallback(['LD_host'], ld_host)
# The environment variable could be used in 'make_global_settings', like
# ['CC.host', '$(CC)'] or ['CXX.host', '$(CXX)'], transform them here.
if '$(CC)' in cc_host and cc_host_global_setting:
cc_host = cc_host_global_setting.replace('$(CC)', cc)
if '$(CXX)' in cxx_host and cxx_host_global_setting:
cxx_host = cxx_host_global_setting.replace('$(CXX)', cxx)
master_ninja.variable('cc_host',
CommandWithWrapper('CC.host', wrappers, cc_host))
master_ninja.variable('cxx_host',
CommandWithWrapper('CXX.host', wrappers, cxx_host))
if flavor == 'win':
master_ninja.variable('ld_host', ld_host)
else:
master_ninja.variable('ld_host', CommandWithWrapper(
'LINK', wrappers, ld_host))
master_ninja.newline()
master_ninja.pool('link_pool', depth=GetDefaultConcurrentLinks())
master_ninja.newline()
deps = 'msvc' if flavor == 'win' else 'gcc'
if flavor != 'win':
master_ninja.rule(
'cc',
description='CC $out',
command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c '
'$cflags_pch_c -c $in -o $out'),
depfile='$out.d',
deps=deps)
master_ninja.rule(
'cc_s',
description='CC $out',
command=('$cc $defines $includes $cflags $cflags_c '
'$cflags_pch_c -c $in -o $out'))
master_ninja.rule(
'cxx',
description='CXX $out',
command=('$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_cc '
'$cflags_pch_cc -c $in -o $out'),
depfile='$out.d',
deps=deps)
else:
cc_command = ('ninja -t msvc -e $arch ' +
'-- '
'$cc /nologo /showIncludes /FC '
'@$out.rsp /c $in /Fo$out /Fd$pdbname ')
cxx_command = ('ninja -t msvc -e $arch ' +
'-- '
'$cxx /nologo /showIncludes /FC '
'@$out.rsp /c $in /Fo$out /Fd$pdbname ')
master_ninja.rule(
'cc',
description='CC $out',
command=cc_command,
rspfile='$out.rsp',
rspfile_content='$defines $includes $cflags $cflags_c',
deps=deps)
master_ninja.rule(
'cxx',
description='CXX $out',
command=cxx_command,
rspfile='$out.rsp',
rspfile_content='$defines $includes $cflags $cflags_cc',
deps=deps)
master_ninja.rule(
'idl',
description='IDL $in',
command=('%s gyp-win-tool midl-wrapper $arch $outdir '
'$tlb $h $dlldata $iid $proxy $in '
'$idlflags' % sys.executable))
master_ninja.rule(
'rc',
description='RC $in',
# Note: $in must be last otherwise rc.exe complains.
command=('%s gyp-win-tool rc-wrapper '
'$arch $rc $defines $includes $rcflags /fo$out $in' %
sys.executable))
master_ninja.rule(
'asm',
description='ASM $in',
command=('%s gyp-win-tool asm-wrapper '
'$arch $asm $defines $includes /c /Fo $out $in' %
sys.executable))
if flavor != 'mac' and flavor != 'win':
master_ninja.rule(
'alink',
description='AR $out',
command='rm -f $out && $ar rcs $out $in')
master_ninja.rule(
'alink_thin',
description='AR $out',
command='rm -f $out && $ar rcsT $out $in')
# This allows targets that only need to depend on $lib's API to declare an
# order-only dependency on $lib.TOC and avoid relinking such downstream
# dependencies when $lib changes only in non-public ways.
# The resulting string leaves an uninterpolated %{suffix} which
# is used in the final substitution below.
mtime_preserving_solink_base = (
'if [ ! -e $lib -o ! -e ${lib}.TOC ]; then '
'%(solink)s && %(extract_toc)s > ${lib}.TOC; else '
'%(solink)s && %(extract_toc)s > ${lib}.tmp && '
'if ! cmp -s ${lib}.tmp ${lib}.TOC; then mv ${lib}.tmp ${lib}.TOC ; '
'fi; fi'
% { 'solink':
'$ld -shared $ldflags -o $lib -Wl,-soname=$soname %(suffix)s',
'extract_toc':
('{ readelf -d ${lib} | grep SONAME ; '
'nm -gD -f p ${lib} | cut -f1-2 -d\' \'; }')})
master_ninja.rule(
'solink',
description='SOLINK $lib',
restat=True,
command=(mtime_preserving_solink_base % {
'suffix': '-Wl,--whole-archive $in $solibs -Wl,--no-whole-archive '
'$libs'}),
pool='link_pool')
master_ninja.rule(
'solink_module',
description='SOLINK(module) $lib',
restat=True,
command=(mtime_preserving_solink_base % {
'suffix': '-Wl,--start-group $in $solibs -Wl,--end-group '
'$libs'}),
pool='link_pool')
master_ninja.rule(
'link',
description='LINK $out',
command=('$ld $ldflags -o $out '
'-Wl,--start-group $in $solibs -Wl,--end-group $libs'),
pool='link_pool')
elif flavor == 'win':
master_ninja.rule(
'alink',
description='LIB $out',
command=('%s gyp-win-tool link-wrapper $arch '
'$ar /nologo /ignore:4221 /OUT:$out @$out.rsp' %
sys.executable),
rspfile='$out.rsp',
rspfile_content='$in_newline $libflags')
_AddWinLinkRules(master_ninja, embed_manifest=True, link_incremental=True)
_AddWinLinkRules(master_ninja, embed_manifest=True, link_incremental=False)
_AddWinLinkRules(master_ninja, embed_manifest=False, link_incremental=False)
# Do not generate rules for embed_manifest=False and link_incremental=True
# because in that case rules for (False, False) should be used (see
# implementation of _GetWinLinkRuleNameSuffix()).
else:
master_ninja.rule(
'objc',
description='OBJC $out',
command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc '
'$cflags_pch_objc -c $in -o $out'),
depfile='$out.d',
deps=deps)
master_ninja.rule(
'objcxx',
description='OBJCXX $out',
command=('$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_objcc '
'$cflags_pch_objcc -c $in -o $out'),
depfile='$out.d',
deps=deps)
master_ninja.rule(
'alink',
description='LIBTOOL-STATIC $out, POSTBUILDS',
command='rm -f $out && '
'./gyp-mac-tool filter-libtool libtool $libtool_flags '
'-static -o $out $in'
'$postbuilds')
# Record the public interface of $lib in $lib.TOC. See the corresponding
# comment in the posix section above for details.
mtime_preserving_solink_base = (
'if [ ! -e $lib -o ! -e ${lib}.TOC ] || '
# Always force dependent targets to relink if this library
# reexports something. Handling this correctly would require
# recursive TOC dumping but this is rare in practice, so punt.
'otool -l $lib | grep -q LC_REEXPORT_DYLIB ; then '
'%(solink)s && %(extract_toc)s > ${lib}.TOC; '
'else '
'%(solink)s && %(extract_toc)s > ${lib}.tmp && '
'if ! cmp -s ${lib}.tmp ${lib}.TOC; then '
'mv ${lib}.tmp ${lib}.TOC ; '
'fi; '
'fi'
% { 'solink': '$ld -shared $ldflags -o $lib %(suffix)s',
'extract_toc':
'{ otool -l $lib | grep LC_ID_DYLIB -A 5; '
'nm -gP $lib | cut -f1-2 -d\' \' | grep -v U$$; true; }'})
# TODO(thakis): The solink_module rule is likely wrong. Xcode seems to pass
# -bundle -single_module here (for osmesa.so).
master_ninja.rule(
'solink',
description='SOLINK $lib, POSTBUILDS',
restat=True,
command=(mtime_preserving_solink_base % {
'suffix': '$in $solibs $libs$postbuilds'}),
pool='link_pool')
master_ninja.rule(
'solink_module',
description='SOLINK(module) $lib, POSTBUILDS',
restat=True,
command=(mtime_preserving_solink_base % {
'suffix': '$in $solibs $libs$postbuilds'}),
pool='link_pool')
master_ninja.rule(
'link',
description='LINK $out, POSTBUILDS',
command=('$ld $ldflags -o $out '
'$in $solibs $libs$postbuilds'),
pool='link_pool')
master_ninja.rule(
'infoplist',
description='INFOPLIST $out',
command=('$cc -E -P -Wno-trigraphs -x c $defines $in -o $out && '
'plutil -convert xml1 $out $out'))
master_ninja.rule(
'mac_tool',
description='MACTOOL $mactool_cmd $in',
command='$env ./gyp-mac-tool $mactool_cmd $in $out')
master_ninja.rule(
'package_framework',
description='PACKAGE FRAMEWORK $out, POSTBUILDS',
command='./gyp-mac-tool package-framework $out $version$postbuilds '
'&& touch $out')
if flavor == 'win':
master_ninja.rule(
'stamp',
description='STAMP $out',
command='%s gyp-win-tool stamp $out' % sys.executable)
master_ninja.rule(
'copy',
description='COPY $in $out',
command='%s gyp-win-tool recursive-mirror $in $out' % sys.executable)
else:
master_ninja.rule(
'stamp',
description='STAMP $out',
command='${postbuilds}touch $out')
master_ninja.rule(
'copy',
description='COPY $in $out',
command='ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)')
master_ninja.newline()
all_targets = set()
for build_file in params['build_files']:
for target in gyp.common.AllTargets(target_list,
target_dicts,
os.path.normpath(build_file)):
all_targets.add(target)
all_outputs = set()
# target_outputs is a map from qualified target name to a Target object.
target_outputs = {}
# target_short_names is a map from target short name to a list of Target
# objects.
target_short_names = {}
for qualified_target in target_list:
# qualified_target is like: third_party/icu/icu.gyp:icui18n#target
build_file, name, toolset = \
gyp.common.ParseQualifiedTarget(qualified_target)
this_make_global_settings = data[build_file].get('make_global_settings', [])
assert make_global_settings == this_make_global_settings, (
"make_global_settings needs to be the same for all targets.")
spec = target_dicts[qualified_target]
if flavor == 'mac':
gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
build_file = gyp.common.RelativePath(build_file, options.toplevel_dir)
base_path = os.path.dirname(build_file)
obj = 'obj'
if toolset != 'target':
obj += '.' + toolset
output_file = os.path.join(obj, base_path, name + '.ninja')
writer = NinjaWriter(qualified_target, target_outputs, base_path, build_dir,
OpenOutput(os.path.join(toplevel_build, output_file)),
flavor, toplevel_dir=options.toplevel_dir)
master_ninja.subninja(output_file)
target = writer.WriteSpec(
spec, config_name, generator_flags, case_sensitive_filesystem)
if target:
if name != target.FinalOutput() and spec['toolset'] == 'target':
target_short_names.setdefault(name, []).append(target)
target_outputs[qualified_target] = target
if qualified_target in all_targets:
all_outputs.add(target.FinalOutput())
if target_short_names:
# Write a short name to build this target. This benefits both the
# "build chrome" case as well as the gyp tests, which expect to be
# able to run actions and build libraries by their short name.
master_ninja.newline()
master_ninja.comment('Short names for targets.')
for short_name in target_short_names:
master_ninja.build(short_name, 'phony', [x.FinalOutput() for x in
target_short_names[short_name]])
if all_outputs:
master_ninja.newline()
master_ninja.build('all', 'phony', list(all_outputs))
master_ninja.default(generator_flags.get('default_target', 'all'))
def PerformBuild(data, configurations, params):
options = params['options']
for config in configurations:
builddir = os.path.join(options.toplevel_dir, 'out', config)
arguments = ['ninja', '-C', builddir]
print 'Building [%s]: %s' % (config, arguments)
subprocess.check_call(arguments)
def CallGenerateOutputForConfig(arglist):
# Ignore the interrupt signal so that the parent process catches it and
# kills all multiprocessing children.
signal.signal(signal.SIGINT, signal.SIG_IGN)
(target_list, target_dicts, data, params, config_name) = arglist
GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
def GenerateOutput(target_list, target_dicts, data, params):
user_config = params.get('generator_flags', {}).get('config', None)
if gyp.common.GetFlavor(params) == 'win':
target_list, target_dicts = MSVSUtil.ShardTargets(target_list, target_dicts)
target_list, target_dicts = MSVSUtil.InsertLargePdbShims(
target_list, target_dicts, generator_default_variables)
if user_config:
GenerateOutputForConfig(target_list, target_dicts, data, params,
user_config)
else:
config_names = target_dicts[target_list[0]]['configurations'].keys()
if params['parallel']:
try:
pool = multiprocessing.Pool(len(config_names))
arglists = []
for config_name in config_names:
arglists.append(
(target_list, target_dicts, data, params, config_name))
pool.map(CallGenerateOutputForConfig, arglists)
except KeyboardInterrupt, e:
pool.terminate()
raise e
else:
for config_name in config_names:
GenerateOutputForConfig(target_list, target_dicts, data, params,
config_name)
|
#!/usr/bin/env python2.7
import BaseHTTPServer
import collections
import logging
import os
import re
import socket
import sys
import signal
import time
import traceback
import urllib
import urlparse
from snmpy import log_error, __version__
LOG = logging.getLogger()
class HTTPError(Exception):
code = 500
def __init__(self, exception=None):
self.line, self.body = Handler.responses[self.code]
if exception is not None:
self.body = ''.join(traceback.format_exception(*exception))
class HTTPForbiddenError(HTTPError):
code = 403
class HTTPNotFoundError(HTTPError):
code = 404
class Response():
def __init__(self, **kwargs):
self.__dict__.update({
'code': 200,
'line': 'OK',
'head': collections.OrderedDict(),
'body': '',
})
for key, val in kwargs.items():
if key == 'head':
self.head.update(kwargs['head'])
else:
setattr(self, key, val)
def __setattr__(self, key, val):
if key.startswith('_') or key == 'head' or key not in self.__dict__:
raise AttributeError('setting attribute %s is not supported' % key)
if key == 'code' and type(val) != int:
raise AttributeError('setting attribute %s requires an integer' % key)
self.__dict__[key] = val
class Server(BaseHTTPServer.HTTPServer):
allow_reuse_address = True
def __init__(self, port, addr='', **kwargs):
BaseHTTPServer.HTTPServer.__init__(self, (addr, port), Handler)
Handler.log_message = lambda *args: True
Handler.extra_settings = collections.namedtuple('extra_settings', kwargs.keys())(*kwargs.values())
Handler.server_version += ' %s/%s' % (__name__, __version__)
try:
self.serve_forever(poll_interval=None)
except KeyboardInterrupt:
LOG.info('stopping snmpy httpd')
def server_bind(self):
self.socket.setsockopt(socket.SOL_TCP, socket.TCP_DEFER_ACCEPT, True)
self.socket.setsockopt(socket.SOL_TCP, socket.TCP_QUICKACK, True)
BaseHTTPServer.HTTPServer.server_bind(self)
def process_request(self, *args):
def handle_timeout(*args):
raise RuntimeError('request timed out')
try:
signal.signal(signal.SIGALRM, handle_timeout)
signal.alarm(10)
BaseHTTPServer.HTTPServer.process_request(self, *args)
except Exception as e:
log_error(e)
finally:
signal.alarm(0)
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
protocol_version = 'HTTP/1.1'
request_handlers = {
'GET': collections.OrderedDict()
}
default_headers = {
'Connection': 'close',
'Content-type': 'text/plain',
}
def route_request(self, method):
self.start_time = time.time() * 1000
self.url = urlparse.urlparse(self.path)
self.path = urllib.unquote(self.url.path)
self.query = urlparse.parse_qs(self.url.query)
response = Response(head=self.default_headers)
try:
for patt, func in self.request_handlers[method].items():
find = patt.match(self.path)
if find:
response = Response(head=self.default_headers)
func(self, response, *(find.groups()))
break
else:
raise HTTPNotFoundError
except Exception as e:
if not isinstance(e, HTTPError):
e = HTTPError(sys.exc_info())
response.code = e.code
response.line = e.line
response.body = e.body
self.send_response(response.code, response.line)
for key, val in response.head.items():
if key.lower() != 'content-length':
self.send_header(key, val)
self.send_header('Content-length', len(response.body))
self.send_header('X-Handler-Time', '%.02fms' % (time.time() * 1000 - self.start_time))
self.send_header('X-Handler-Pid', os.getpid())
self.end_headers()
self.wfile.write(response.body)
def do_GET(self):
self.route_request('GET')
def GET(path=None):
def wrapper(func):
patt = r'/%s(?:/|$)' % (path.strip('/') if path is not None else func.func_name.replace('_', '-'))
Handler.request_handlers['GET'][re.compile(patt)] = func
return wrapper
@GET()
def version(req, res):
res.body = req.server_version + '\r\n'
|
# coding=utf-8
# Copyright 2019 The Google AI Language Team Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""Defines the methods to us for columns selection."""
import collections
import enum
import queue
from typing import Dict, Tuple, Text, Set, Optional, List, Iterable
import apache_beam as beam
import dataclasses
from nltk.stem.porter import PorterStemmer
from tapas.protos import interaction_pb2
from tapas.protos import table_selection_pb2
from tapas.utils import text_utils
from tapas.utils import tf_example_utils
_NS = "main"
_Coordinates = tf_example_utils.TokenCoordinates
def get_column_texts(
table,
column_index,
):
"""Iterates through the text in the column including the header."""
yield table.columns[column_index].text
for row in table.rows:
yield row.cells[column_index].text
def _get_column_cost(
tokenizer,
table,
column_index,
):
r"""Computes length of the serialized column."""
num_tokens = 0
for text in get_column_texts(table, column_index):
num_tokens += len(tokenizer.tokenize(text))
return num_tokens
def _get_question_cost(
tokenizer,
question,
):
r"""Computes length of the serialized question (w/ special token offset)."""
tokens = tokenizer.tokenize(
text_utils.normalize_for_match(question.original_text))
return tokenizer.question_encoding_cost(tokens)
def get_cleaned_seq_tokens(str_tokens):
"""Transform a string to a cleaned list of tokens.
Args:
str_tokens: the string to tokenize
Returns:
A list of tokens
"""
stemmer = PorterStemmer()
tokens = text_utils.tokenize_text(text_utils.format_text(str_tokens))
return [stemmer.stem(token) for token in tokens]
def from_selected_columns_to_selected_tokens(
interaction,
selected_columns,
tokenizer):
r"""Gets all the tokens' coordinates of the selected columns."""
selected_tokens = set()
def _add_cell_tokens(column_index, row_index, cell_text, selected_tokens):
cell_tokens = tokenizer.tokenize(cell_text)
for token_index in range(len(cell_tokens)):
selected_tokens.add(
_Coordinates(
column_index=column_index,
row_index=row_index,
token_index=token_index))
for column_index in selected_columns:
_add_cell_tokens(column_index, 0,
interaction.table.columns[column_index].text,
selected_tokens)
for row_index, row in enumerate(interaction.table.rows):
_add_cell_tokens(column_index, row_index + 1,
row.cells[column_index].text, selected_tokens)
return selected_tokens
def _get_question_column_similarity(column_tokens,
question_tokens,
epsilon = 0.0):
r"""Gives the scored using Jaccard coefficient.
(for more details see https://en.wikipedia.org/wiki/Jaccard_index)
Formula: score = |{token \in C | token \in Q}| / |{token\in C}|.
Where C contains all the tokens extracted from the column i's strings
and Q the question's string.
Args:
column_tokens: expected set of tokens from one column
question_tokens: expected set of tokens from one question
epsilon: expected value >= 0.0. In some cases the expected returned values >
0.0 (non zero). The epsilon must be set to a value > 0.0.
Returns:
The Jaccard coefficient
"""
nominator = column_tokens & question_tokens
denominator = column_tokens | question_tokens
if not denominator and not epsilon:
return 0.0
return (len(nominator) + epsilon) / (len(denominator) + epsilon)
class SelectionType(enum.Enum):
COLUMN = 1
CELL = 2
@dataclasses.dataclass
class TokenScoreDebugInfo:
score: float = 0.0
nb_tokens: int = 0
@dataclasses.dataclass(frozen=True)
class TokenSelection:
selected_tokens: Set[_Coordinates]
debug: Optional[table_selection_pb2.TableSelection.DebugInfo] = None
class TokenSelector:
"""Base class for column selection."""
def __init__(self, vocab_file, use_previous_questions):
self._use_previous_questions = use_previous_questions
self._tokenizer = tf_example_utils.TapasTokenizer(vocab_file)
def prepare(self):
pass
def select_tokens(
self,
interaction,
question,
):
raise NotImplementedError()
def annotated_interaction(
self,
interaction,
):
"""Selects columns using select_columns_fn for each question in the current interaction."""
new_interaction = interaction_pb2.Interaction()
new_interaction.CopyFrom(interaction)
questions = []
for q in new_interaction.questions:
text = q.text
if self._use_previous_questions:
questions.append(q.original_text)
q.text = " ".join(questions)
else:
q.text = q.original_text
token_selection = self.select_tokens(interaction, q)
q.text = text
selected_tokens = token_selection.selected_tokens
table_ext = table_selection_pb2.TableSelection.table_selection_ext
question_tokens = q.Extensions[table_ext].selected_tokens
del question_tokens[:]
for token in selected_tokens:
new_token = question_tokens.add()
new_token.column_index = token.column_index
new_token.row_index = token.row_index
new_token.token_index = token.token_index
if token_selection.debug:
q.Extensions[table_ext].debug.CopyFrom(token_selection.debug)
return new_interaction
class MaxTokenSelector(TokenSelector):
"""Selects columns until a certain number of tokens is met."""
def __init__(self, vocab_file, max_nb_tokens,
selection_level, use_previous_answer,
use_previous_questions):
super().__init__(
vocab_file=vocab_file, use_previous_questions=use_previous_questions)
self._max_nb_tokens = max_nb_tokens
self._use_previous_answer = use_previous_answer
# Extracts columns or cells depending on the selection_level.
if selection_level == SelectionType.CELL:
self.select_tokens = self._select_cells
elif selection_level == SelectionType.COLUMN:
self.select_tokens = self._select_columns
else:
raise ValueError(
f"The selection level is not implemented {selection_level}")
def _get_column_tokens(self, interaction,
column_index):
column_tokens = []
for row in interaction.table.rows:
column_tokens.extend(get_cleaned_seq_tokens(row.cells[column_index].text))
column_tokens.extend(
get_cleaned_seq_tokens(interaction.table.columns[column_index].text))
return column_tokens
def _get_columns_tokens(
self, interaction):
return {
column_index: self._get_column_tokens(interaction, column_index)
for column_index in range(len(interaction.table.columns))
}
def _get_columns_similarity_scores(
self, interaction,
question_tokens):
columns_tokens = self._get_columns_tokens(interaction)
columns_score = {
column_index:
_get_question_column_similarity(set(column_tokens), question_tokens)
for column_index, column_tokens in columns_tokens.items()
}
return columns_score
def _get_headers_tokens(
self, interaction):
return {
column_index: get_cleaned_seq_tokens(column.text)
for column_index, column in enumerate(interaction.table.columns)
}
def _get_headers_similarity_scores(
self, interaction,
question_tokens):
headers_tokens = self._get_headers_tokens(interaction)
return {
column_index:
_get_question_column_similarity(set(header_token), question_tokens)
for column_index, header_token in headers_tokens.items()
}
def _get_cells(
self, interaction
):
r"""Extracts cells tokens.
Args:
interaction: Contains the table cells.
Returns:
Dictionary where the keys are the row indexe and column index of the cell.
The value is the list of tokens o a cell.
"""
cells = {}
for column_index in range(len(interaction.table.columns)):
cells[(column_index, 0)] = get_cleaned_seq_tokens(
interaction.table.columns[column_index].text)
for row_index, row in enumerate(interaction.table.rows):
cells[(column_index, row_index + 1)] = get_cleaned_seq_tokens(
row.cells[column_index].text)
return cells
def _get_row_tokens(self, interaction,
row_index):
row_tokens = []
for column_index in range(len(interaction.table.columns)):
cell_tokens = get_cleaned_seq_tokens(
interaction.table.rows[row_index].cells[column_index].text)
row_tokens.extend(cell_tokens)
return row_tokens
def _get_header_tokens(
self, interaction):
row_tokens = []
for column in interaction.table.columns:
cell_tokens = get_cleaned_seq_tokens(column.text)
row_tokens.extend(cell_tokens)
return row_tokens
def _get_row_similarity_scores(
self, interaction,
question_tokens):
r"""Computes the rows scores.
Args:
interaction: Contains the table cells.
question_tokens: List of the question tokens.
Returns:
Dictionary where the keys are the rows' indexes.
Row index = 0 is the header.
"""
header_tokens = self._get_header_tokens(interaction)
row_scores = {
0: _get_question_column_similarity(set(header_tokens), question_tokens)
}
for row_index in range(len(interaction.table.rows)):
row_tokens = self._get_row_tokens(interaction, row_index)
row_scores[row_index + 1] = _get_question_column_similarity(
set(row_tokens), question_tokens)
return row_scores
def _update_priority_queue_from_previous_answer(
self,
selection_type,
priority_queue,
interaction,
question,
):
r"""gives high priority to a answer columns from the previous question.
Args:
selection_type: Specify the selection type: column or a cell.
priority_queue: expected values: Tuple (-score, index of scored column) or
Tuple (-score, index of scored column, index of row , index of token)
interaction: contains the table cells.
question: contains the original text of the question.
Returns:
A modified priority queue.
"""
if not self._use_previous_answer:
return priority_queue
if len(interaction.questions) > 1:
index = 0
for index, q in enumerate(interaction.questions):
if q.id == question.id:
break
if index > 0:
answer_coords = interaction.questions[index -
1].answer.answer_coordinates
if selection_type == SelectionType.COLUMN:
answer_coords = set([c.column_index for c in answer_coords])
elif selection_type == SelectionType.CELL:
answer_coords = [(c.row_index, c.column_index) for c in answer_coords]
else:
raise NotImplementedError()
new_priority_queue = queue.PriorityQueue()
# The priority queue prioritize the minimum scores:
# max_priority_score = - max_score
max_priority_score = -len(interaction.table.columns)
while not priority_queue.empty():
element = priority_queue.get()
if selection_type == SelectionType.COLUMN:
_, index_look_up = element
new_element = (max_priority_score, index_look_up)
elif selection_type == SelectionType.CELL:
_, column_index, row_index, token_index = element
index_look_up = (row_index, column_index)
new_element = (max_priority_score, column_index, row_index,
token_index)
else:
raise NotImplementedError()
if index_look_up in answer_coords:
new_priority_queue.put(new_element)
else:
new_priority_queue.put(element)
return new_priority_queue
return priority_queue
def _get_columns_from_priority_queue(
self,
columns_queue,
interaction,
question,
):
r"""Selects tokenss with higher score up to max_nb_tokens.
Args:
columns_queue: expected values: Tuple (-score, index of scored column)
interaction: contains the table cells.
question: contains the original text of the question.
Returns:
The set of selected columns' indexes.
"""
columns_queue = self._update_priority_queue_from_previous_answer(
SelectionType.COLUMN, columns_queue, interaction, question)
selected_columns = set()
num_tokens = _get_question_cost(self._tokenizer, question)
table = interaction.table
num_columns_skipped = 0
debug = table_selection_pb2.TableSelection.DebugInfo()
while not columns_queue.empty():
score, column_index = columns_queue.get()
column_cost = _get_column_cost(self._tokenizer, table, column_index)
column_debug = debug.columns.add()
column_debug.index = column_index
column_debug.score = -float(score)
# Selects columns without exceeding maximum number of tokens.
if num_tokens + column_cost > self._max_nb_tokens:
num_columns_skipped += 1
column_debug.is_selected = False
continue
column_debug.is_selected = True
if num_columns_skipped > 0:
beam.metrics.Metrics.counter(_NS, "Squeezing in another column").inc()
num_tokens += column_cost
selected_columns.add(column_index)
if not selected_columns:
beam.metrics.Metrics.counter(_NS, "No column selected").inc()
if num_columns_skipped == 0:
beam.metrics.Metrics.counter(_NS, "All columns selected").inc()
else:
beam.metrics.Metrics.counter(_NS, "Columns removed").\
inc(num_columns_skipped)
# Check if an answer column wasn't selected.
for answer_coordinate in question.answer.answer_coordinates:
answer_column_index = answer_coordinate.column_index
if answer_column_index < 0:
continue
if answer_column_index not in selected_columns:
beam.metrics.Metrics.counter(_NS, "Answer columns removed").inc()
if not question.answer.HasField("float_value"):
beam.metrics.Metrics.counter(_NS, "Unambiguous columns removed").inc()
break
selected_tokens = from_selected_columns_to_selected_tokens(
interaction, selected_columns, self._tokenizer)
return TokenSelection(selected_tokens, debug)
def _get_tokens_from_priority_queue(
self,
tokens_queue,
interaction,
question,
):
r"""Selects tokenss with higher score up to max_nb_tokens.
Args:
tokens_queue: expected values: Tuple (-score, column_index, row_index,
token_index)
interaction: contains the table cells.
question: contains the original text of the question.
Returns:
The set of selected columns' indexes.
"""
tokens_queue = self._update_priority_queue_from_previous_answer(
SelectionType.CELL, tokens_queue, interaction, question)
table = interaction.table
selected_tokens = set()
num_tokens = _get_question_cost(self._tokenizer, question)
debug = table_selection_pb2.TableSelection.DebugInfo()
debug_column = collections.defaultdict(TokenScoreDebugInfo)
cell_score = collections.defaultdict(lambda: 0.0)
if num_tokens > self._max_nb_tokens:
beam.metrics.Metrics.counter(_NS, "No column selected").inc()
return TokenSelection(selected_tokens)
while not tokens_queue.empty() and num_tokens < self._max_nb_tokens:
num_tokens += 1
score, column_index, row_index, token_index = tokens_queue.get()
selected_tokens.add(_Coordinates(column_index, row_index, token_index))
debug_column[column_index].score -= float(score)
debug_column[column_index].nb_tokens += 1
previous_score = cell_score[(column_index, row_index)]
cell_score[(column_index, row_index)] = max(-float(score), previous_score)
# Add debug for column selection.
num_columns_skipped = 0
num_tokens_skipped = 0
num_cells_skipped = 0
for column_index in range(len(table.columns)):
column_debug = debug.columns.add()
column_debug.index = column_index
if column_index in debug_column.keys():
debug_info = debug_column[column_index]
column_debug.score = debug_info.score / debug_info.nb_tokens
column_debug.is_selected = True
column_cost = _get_column_cost(self._tokenizer, table, column_index)
num_tokens_skipped += column_cost - debug_info.nb_tokens
num_rows_selected = len(
set(coord.row_index
for coord in selected_tokens
if coord.column_index == column_index))
num_cells_skipped += len(table.rows) + 1 - num_rows_selected
else:
column_debug.score = 0.0
column_debug.is_selected = False
num_columns_skipped += 1
if num_tokens_skipped == 0:
beam.metrics.Metrics.counter(_NS, "All tokens are selected").inc()
else:
beam.metrics.Metrics.counter(_NS,
"Tokens removed").inc(num_tokens_skipped)
if num_cells_skipped == 0:
beam.metrics.Metrics.counter(
_NS, "Selected at least one token of every cell").inc()
else:
beam.metrics.Metrics.counter(
_NS, "Cells removed (no token selected)").inc(num_cells_skipped)
if num_columns_skipped == 0:
beam.metrics.Metrics.counter(
_NS, "Selected at least one token of every column").inc()
else:
beam.metrics.Metrics.counter(
_NS, "Columns removed (no token selected)").inc(num_columns_skipped)
# Check if an answer column wasn't selected.
scored_zero = 0
for answer_coordinate in question.answer.answer_coordinates:
answer_column_index = answer_coordinate.column_index
answer_row_index = answer_coordinate.row_index
if answer_column_index < 0:
continue
if (answer_column_index, answer_row_index) in cell_score.keys():
found_score = cell_score[(answer_column_index, answer_row_index)]
if found_score == 0:
scored_zero += 1
else:
beam.metrics.Metrics.counter(_NS, "Answer cells removed").inc()
if not question.answer.HasField("float_value"):
beam.metrics.Metrics.counter(_NS, "Unambiguous cells removed").inc()
break
if scored_zero > 0:
beam.metrics.Metrics.counter(_NS,
"Answer cell is scored 0").inc(scored_zero)
return TokenSelection(selected_tokens, debug)
def _select_columns(
self,
interaction,
question,
):
raise NotImplementedError()
def _select_cells(
self,
interaction,
question,
):
raise NotImplementedError()
class HeuristicExactMatchTokenSelector(MaxTokenSelector):
r"""Extracts columns that contain tokens'strings match a subset of the question's string."""
def _select_columns(
self,
interaction,
question,
):
r"""Extracts columns that contain tokens'strings match a subset of the question's string.
Args:
interaction: contains the cells.
question: contains the original text of the question.
Returns:
The set of selected columns' indexes.
"""
question_tokens = set(get_cleaned_seq_tokens(question.text))
columns_queue = queue.PriorityQueue()
for i in range(len(interaction.table.columns)):
column_tokens = self._get_column_tokens(interaction, i)
score = _get_question_column_similarity(
set(column_tokens), question_tokens)
columns_queue.put((-score, i))
return self._get_columns_from_priority_queue(columns_queue, interaction,
question)
def _select_cells(
self,
interaction,
question,
):
r"""Extracts cells that contain tokens'strings match a subset of the question's string.
The final score used for the priority queue is cell_score + column_score +
row_score.
Args:
interaction: contains the cells.
question: contains the original text of the question.
Returns:
The set of selected tokens' indexes.
"""
question_tokens = set(get_cleaned_seq_tokens(question.text))
rows_scores = self._get_row_similarity_scores(interaction, question_tokens)
columns_scores = self._get_columns_similarity_scores(
interaction, question_tokens)
cells = self._get_cells(interaction)
tokens_queue = queue.PriorityQueue()
for indexes, cell_tokens in cells.items():
column_index, row_index = indexes
row_score = rows_scores[row_index]
column_score = columns_scores[column_index]
cell_score = _get_question_column_similarity(
set(cell_tokens), question_tokens)
score = column_score + row_score + cell_score
for token_index in range(len(cell_tokens)):
tokens_queue.put((-score, column_index, row_index, token_index))
return self._get_tokens_from_priority_queue(tokens_queue, interaction,
question)
class SelectAllTokensFn(TokenSelector):
"""Extracts all the columns."""
def select_tokens(self, interaction,
question):
r"""Extracts all the columns.
Args:
interaction: gives the number of columns.
question: not used.
Returns:
The set of all columns' indexes.
"""
del question # Unused
selected_columns = set(range(len(interaction.table.columns)))
selected_tokens = from_selected_columns_to_selected_tokens(
interaction, selected_columns, self._tokenizer)
return TokenSelection(selected_tokens)
|
#!/usr/bin/env python3
MOD = 2 ** 16
def func0():
if j < 0:
return x1 << -j
else:
return x1 >> j
def func1():
if j < 0:
return y >> -j
else:
return y << j
x1 = int(input(), 16)
x0 = 0
a = 0
y = 0
n = 0
c = 0
t = x1
while t > 0:
t >>= 1
n += 1
n += 16
n += n & 1
print(hex(x1), '=', x1)
print( '{:2}'.format('i'),
'{:1}'.format('c'),
'{:6}'.format('a'),
'{:8}'.format('y'),
'{:6}'.format('x1'),
'{:6}'.format('x0'),
'{:6}'.format('x21'),
'{:6}'.format('x20'),
'{:6}'.format('y21'),
'{:6}'.format('y20'),
)
for i in range(n, -1, -2):
j = i - 16
y21 = 0
a <<= 1
y <<= 1
if y >= MOD:
y %= MOD # 下16ビットをとる
y21 += 1
y20 = 1 | y
c = True
f0 = func0() % MOD
x20 = x0 >> i
x20 += f0
x21 = x1 >> i
if x21 < y21:
c = False
if x21 == y21:
if x20 < y20:
c = False
if c:
a += 1
y += 1
x1 -= func1()
x0 -= (y << i) % MOD # 下16ビットをとる
if x0 < 0:
x1 -= 1
x0 += MOD # 下16ビットをとる
y += 1
print( '{:02}'.format(i),
'{:1}'.format(c),
'{:#06x}'.format(a),
'{:#08x}'.format(y),
'{:#06x}'.format(x1),
'{:#06x}'.format(x0),
'{:#06x}'.format(x21),
'{:#06x}'.format(x20),
'{:#06x}'.format(y21),
'{:#06x}'.format(y20),
)
print(hex(a), '=', a / 256)
|
# -*-coding:Utf-8 -*
# Copyright (c) 2010-2017 CORTIER Benoît
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""Package contenant la commande 'decrire'"""
from primaires.interpreteur.commande.commande import Commande
class CmdDecrire(Commande):
"""Commande 'decrire'.
"""
def __init__(self):
"""Constructeur de la commande"""
Commande.__init__(self, "décrire", "describe")
self.groupe = "joueur"
self.aide_courte = "Ouvre un éditeur pour se décrire."
self.aide_longue = \
"Cette commande permet de manipuler votre description. " \
"Elle ouvre un éditeur dans lequel vous pouvez modifier " \
"cette description. La description doit d'abord être validée " \
"par un administrateur avant d'être visible à tous."
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
editeur = type(self).importeur.interpreteur.construire_editeur(
"descedit", personnage, personnage)
personnage.contextes.ajouter(editeur)
editeur.actualiser()
|
#!/usr/bin/env python
import fileinput
import sys
///<summary>
///Provides a bunch of operations to format and manage hard disks.
///
///One cool thing that this class does is allow you to generate a fstab file
///based on disk formatting operations conducted earlier using this class. This
///is helpful when installing a new Gentoo installation.
///</summary>
class BuildKernel:
def compileNewKernel(self, kernelType, initSettings):
f = fopen('/etc/superGentoo/kernel', 'w')
f.write(kernelType + "," + initSettings)
f.close()
os.system("emerge " + kernelType)
os.system("mv /usr/src/.config /usr/src/linux/.config")
os.system("touch /usr/src/linux/.config")
os.system("cd /usr/src/linux")
os.system("make")
os.system("make modules_install")
os.system("cp arch/x86_64/boot/bzImage /boot/kernel-`find /usr/src -name linux-3* | awk -Flinux- '{print \$NF }'`")
def upgradeKernel(self):
kernelData = open('/etc/superGentoo/kernel').read(1000).split(",")
os.system("emerge --update ". kernelData[0])
os.system()
//--------------------------------------------------------------------------//
// MAIN FUNCTION
//--------------------------------------------------------------------------//
if __name__ == '__main__':
bk = BuildKernel()
if sys.argv[1] == "upgrade":
bk.upgradeKernel()
elif sys.argv[1] == "newKernel":
bk.compileNewKernel(sys.argv[2], sys.argv[3])
|
# Copyright 2012 Nebula, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import collections
import copy
from importlib import import_module
import inspect
import logging
from django.conf import settings
from django import forms
from django.forms.forms import NON_FIELD_ERRORS
from django import template
from django.template.defaultfilters import linebreaks
from django.template.defaultfilters import safe
from django.template.defaultfilters import slugify
from django import urls
from django.utils.encoding import force_text
from django.utils import module_loading
from django.utils.translation import ugettext_lazy as _
from openstack_auth import policy
import six
from horizon import base
from horizon import exceptions
from horizon.templatetags.horizon import has_permissions
from horizon.utils import html
LOG = logging.getLogger(__name__)
class WorkflowContext(dict):
def __init__(self, workflow, *args, **kwargs):
super(WorkflowContext, self).__init__(*args, **kwargs)
self._workflow = workflow
def __setitem__(self, key, val):
super(WorkflowContext, self).__setitem__(key, val)
return self._workflow._trigger_handlers(key)
def __delitem__(self, key):
return self.__setitem__(key, None)
def set(self, key, val):
return self.__setitem__(key, val)
def unset(self, key):
return self.__delitem__(key)
class ActionMetaclass(forms.forms.DeclarativeFieldsMetaclass):
def __new__(mcs, name, bases, attrs):
# Pop Meta for later processing
opts = attrs.pop("Meta", None)
# Create our new class
cls = super(ActionMetaclass, mcs).__new__(mcs, name, bases, attrs)
# Process options from Meta
cls.name = getattr(opts, "name", name)
cls.slug = getattr(opts, "slug", slugify(name))
cls.permissions = getattr(opts, "permissions", ())
cls.policy_rules = getattr(opts, "policy_rules", ())
cls.progress_message = getattr(opts,
"progress_message",
_("Processing..."))
cls.help_text = getattr(opts, "help_text", "")
cls.help_text_template = getattr(opts, "help_text_template", None)
return cls
@six.python_2_unicode_compatible
@six.add_metaclass(ActionMetaclass)
class Action(forms.Form):
"""An ``Action`` represents an atomic logical interaction with the system.
This is easier to understand with a conceptual example: in the context of
a "launch instance" workflow, actions would include "naming the instance",
"selecting an image", and ultimately "launching the instance".
Because ``Actions`` are always interactive, they always provide form
controls, and thus inherit from Django's ``Form`` class. However, they
have some additional intelligence added to them:
* ``Actions`` are aware of the permissions required to complete them.
* ``Actions`` have a meta-level concept of "help text" which is meant to be
displayed in such a way as to give context to the action regardless of
where the action is presented in a site or workflow.
* ``Actions`` understand how to handle their inputs and produce outputs,
much like :class:`~horizon.forms.SelfHandlingForm` does now.
``Action`` classes may define the following attributes in a ``Meta``
class within them:
.. attribute:: name
The verbose name for this action. Defaults to the name of the class.
.. attribute:: slug
A semi-unique slug for this action. Defaults to the "slugified" name
of the class.
.. attribute:: permissions
A list of permission names which this action requires in order to be
completed. Defaults to an empty list (``[]``).
.. attribute:: policy_rules
list of scope and rule tuples to do policy checks on, the
composition of which is (scope, rule)
* scope: service type managing the policy for action
* rule: string representing the action to be checked
for a policy that requires a single rule check::
policy_rules should look like
"(("compute", "compute:create_instance"),)"
for a policy that requires multiple rule checks::
rules should look like
"(("identity", "identity:list_users"),
("identity", "identity:list_roles"))"
where two service-rule clauses are OR-ed.
.. attribute:: help_text
A string of simple help text to be displayed alongside the Action's
fields.
.. attribute:: help_text_template
A path to a template which contains more complex help text to be
displayed alongside the Action's fields. In conjunction with
:meth:`~horizon.workflows.Action.get_help_text` method you can
customize your help text template to display practically anything.
"""
def __init__(self, request, context, *args, **kwargs):
if request.method == "POST":
super(Action, self).__init__(request.POST, initial=context)
else:
super(Action, self).__init__(initial=context)
if not hasattr(self, "handle"):
raise AttributeError("The action %s must define a handle method."
% self.__class__.__name__)
self.request = request
self._populate_choices(request, context)
self.required_css_class = 'required'
def __str__(self):
return force_text(self.name)
def __repr__(self):
return "<%s: %s>" % (self.__class__.__name__, self.slug)
def _populate_choices(self, request, context):
for field_name, bound_field in self.fields.items():
meth = getattr(self, "populate_%s_choices" % field_name, None)
if meth is not None and callable(meth):
bound_field.choices = meth(request, context)
def get_help_text(self, extra_context=None):
"""Returns the help text for this step."""
text = ""
extra_context = extra_context or {}
if self.help_text_template:
tmpl = template.loader.get_template(self.help_text_template)
text += tmpl.render(extra_context, self.request)
else:
text += linebreaks(force_text(self.help_text))
return safe(text)
def add_action_error(self, message):
"""Adds an error to the Action's Step based on API issues."""
self.errors[NON_FIELD_ERRORS] = self.error_class([message])
def handle(self, request, context):
"""Handles any requisite processing for this action.
The method should return either ``None`` or a dictionary of data
to be passed to :meth:`~horizon.workflows.Step.contribute`.
Returns ``None`` by default, effectively making it a no-op.
"""
return None
class MembershipAction(Action):
"""An action that allows a user to add/remove members from a group.
Extend the Action class with additional helper method for membership
management.
"""
def get_default_role_field_name(self):
return "default_" + self.slug + "_role"
def get_member_field_name(self, role_id):
return self.slug + "_role_" + role_id
@six.python_2_unicode_compatible
class Step(object):
"""A wrapper around an action which defines its context in a workflow.
It knows about details such as:
* The workflow's context data (data passed from step to step).
* The data which must be present in the context to begin this step (the
step's dependencies).
* The keys which will be added to the context data upon completion of the
step.
* The connections between this step's fields and changes in the context
data (e.g. if that piece of data changes, what needs to be updated in
this step).
A ``Step`` class has the following attributes:
.. attribute:: action_class
The :class:`~horizon.workflows.Action` class which this step wraps.
.. attribute:: depends_on
A list of context data keys which this step requires in order to
begin interaction.
.. attribute:: contributes
A list of keys which this step will contribute to the workflow's
context data. Optional keys should still be listed, even if their
values may be set to ``None``.
.. attribute:: connections
A dictionary which maps context data key names to lists of callbacks.
The callbacks may be functions, dotted python paths to functions
which may be imported, or dotted strings beginning with ``"self"``
to indicate methods on the current ``Step`` instance.
.. attribute:: before
Another ``Step`` class. This optional attribute is used to provide
control over workflow ordering when steps are dynamically added to
workflows. The workflow mechanism will attempt to place the current
step before the step specified in the attribute.
.. attribute:: after
Another ``Step`` class. This attribute has the same purpose as
:meth:`~horizon.workflows.Step.before` except that it will instead
attempt to place the current step after the given step.
.. attribute:: help_text
A string of simple help text which will be prepended to the ``Action``
class' help text if desired.
.. attribute:: template_name
A path to a template which will be used to render this step. In
general the default common template should be used. Default:
``"horizon/common/_workflow_step.html"``.
.. attribute:: has_errors
A boolean value which indicates whether or not this step has any
errors on the action within it or in the scope of the workflow. This
attribute will only accurately reflect this status after validation
has occurred.
.. attribute:: slug
Inherited from the ``Action`` class.
.. attribute:: name
Inherited from the ``Action`` class.
.. attribute:: permissions
Inherited from the ``Action`` class.
"""
action_class = None
depends_on = ()
contributes = ()
connections = None
before = None
after = None
help_text = ""
template_name = "horizon/common/_workflow_step.html"
def __repr__(self):
return "<%s: %s>" % (self.__class__.__name__, self.slug)
def __str__(self):
return force_text(self.name)
def __init__(self, workflow):
super(Step, self).__init__()
self.workflow = workflow
cls = self.__class__.__name__
if not (self.action_class and issubclass(self.action_class, Action)):
raise AttributeError("action_class not specified for %s." % cls)
self.slug = self.action_class.slug
self.name = self.action_class.name
self.permissions = self.action_class.permissions
self.policy_rules = self.action_class.policy_rules
self.has_errors = False
self._handlers = {}
if self.connections is None:
# We want a dict, but don't want to declare a mutable type on the
# class directly.
self.connections = {}
# Gather our connection handlers and make sure they exist.
for key, handlers in self.connections.items():
self._handlers[key] = []
# TODO(gabriel): This is a poor substitute for broader handling
if not isinstance(handlers, (list, tuple)):
raise TypeError("The connection handlers for %s must be a "
"list or tuple." % cls)
for possible_handler in handlers:
if callable(possible_handler):
# If it's callable we know the function exists and is valid
self._handlers[key].append(possible_handler)
continue
elif not isinstance(possible_handler, six.string_types):
raise TypeError("Connection handlers must be either "
"callables or strings.")
bits = possible_handler.split(".")
if bits[0] == "self":
root = self
for bit in bits[1:]:
try:
root = getattr(root, bit)
except AttributeError:
raise AttributeError("The connection handler %s "
"could not be found on %s."
% (possible_handler, cls))
handler = root
elif len(bits) == 1:
# Import by name from local module not supported
raise ValueError("Importing a local function as a string "
"is not supported for the connection "
"handler %s on %s."
% (possible_handler, cls))
else:
# Try a general import
module_name = ".".join(bits[:-1])
try:
mod = import_module(module_name)
handler = getattr(mod, bits[-1])
except ImportError:
raise ImportError("Could not import %s from the "
"module %s as a connection "
"handler on %s."
% (bits[-1], module_name, cls))
except AttributeError:
raise AttributeError("Could not import %s from the "
"module %s as a connection "
"handler on %s."
% (bits[-1], module_name, cls))
self._handlers[key].append(handler)
@property
def action(self):
if not getattr(self, "_action", None):
try:
# Hook in the action context customization.
workflow_context = dict(self.workflow.context)
context = self.prepare_action_context(self.workflow.request,
workflow_context)
self._action = self.action_class(self.workflow.request,
context)
except Exception:
LOG.exception("Problem instantiating action class.")
raise
return self._action
def prepare_action_context(self, request, context):
"""Hook to customize how the workflow context is passed to the action.
This is the reverse of what "contribute" does to make the
action outputs sane for the workflow. Changes to the context are not
saved globally here. They are localized to the action.
Simply returns the unaltered context by default.
"""
return context
def get_id(self):
"""Returns the ID for this step. Suitable for use in HTML markup."""
return "%s__%s" % (self.workflow.slug, self.slug)
def _verify_contributions(self, context):
for key in self.contributes:
# Make sure we don't skip steps based on weird behavior of
# POST query dicts.
field = self.action.fields.get(key, None)
if field and field.required and not context.get(key):
context.pop(key, None)
failed_to_contribute = set(self.contributes)
failed_to_contribute -= set(context.keys())
if failed_to_contribute:
raise exceptions.WorkflowError("The following expected data was "
"not added to the workflow context "
"by the step %s: %s."
% (self.__class__,
failed_to_contribute))
return True
def contribute(self, data, context):
"""Adds the data listed in ``contributes`` to the workflow's context.
By default, the context is simply updated with all the data
returned by the action.
Note that even if the value of one of the ``contributes`` keys is
not present (e.g. optional) the key should still be added to the
context with a value of ``None``.
"""
if data:
for key in self.contributes:
context[key] = data.get(key, None)
return context
def render(self):
"""Renders the step."""
step_template = template.loader.get_template(self.template_name)
extra_context = {"form": self.action,
"step": self}
return step_template.render(extra_context, self.workflow.request)
def get_help_text(self):
"""Returns the help text for this step."""
text = linebreaks(force_text(self.help_text))
text += self.action.get_help_text()
return safe(text)
def add_step_error(self, message):
"""Adds an error to the Step based on API issues."""
self.action.add_action_error(message)
def has_required_fields(self):
"""Returns True if action contains any required fields."""
return any(field.required for field in self.action.fields.values())
def allowed(self, request):
"""Determines whether or not the step is displayed.
Step instances can override this method to specify conditions under
which this tab should not be shown at all by returning ``False``.
The default behavior is to return ``True`` for all cases.
"""
return True
class WorkflowMetaclass(type):
def __new__(mcs, name, bases, attrs):
super(WorkflowMetaclass, mcs).__new__(mcs, name, bases, attrs)
attrs["_cls_registry"] = []
return type.__new__(mcs, name, bases, attrs)
class UpdateMembersStep(Step):
"""A step that allows a user to add/remove members from a group.
.. attribute:: show_roles
Set to False to disable the display of the roles dropdown.
.. attribute:: available_list_title
The title used for the available list column.
.. attribute:: members_list_title
The title used for the members list column.
.. attribute:: no_available_text
The placeholder text used when the available list is empty.
.. attribute:: no_members_text
The placeholder text used when the members list is empty.
"""
template_name = "horizon/common/_workflow_step_update_members.html"
show_roles = True
available_list_title = _("All available")
members_list_title = _("Members")
no_available_text = _("None available.")
no_members_text = _("No members.")
def get_member_field_name(self, role_id):
if issubclass(self.action_class, MembershipAction):
return self.action.get_member_field_name(role_id)
else:
return self.slug + "_role_" + role_id
@six.python_2_unicode_compatible
@six.add_metaclass(WorkflowMetaclass)
class Workflow(html.HTMLElement):
"""A Workflow is a collection of Steps.
Its interface is very straightforward, but it is responsible for handling
some very important tasks such as:
* Handling the injection, removal, and ordering of arbitrary steps.
* Determining if the workflow can be completed by a given user at runtime
based on all available information.
* Dispatching connections between steps to ensure that when context data
changes all the applicable callback functions are executed.
* Verifying/validating the overall data integrity and subsequently
triggering the final method to complete the workflow.
The ``Workflow`` class has the following attributes:
.. attribute:: name
The verbose name for this workflow which will be displayed to the user.
Defaults to the class name.
.. attribute:: slug
The unique slug for this workflow. Required.
.. attribute:: steps
Read-only access to the final ordered set of step instances for
this workflow.
.. attribute:: default_steps
A list of :class:`~horizon.workflows.Step` classes which serve as the
starting point for this workflow's ordered steps. Defaults to an empty
list (``[]``).
.. attribute:: finalize_button_name
The name which will appear on the submit button for the workflow's
form. Defaults to ``"Save"``.
.. attribute:: success_message
A string which will be displayed to the user upon successful completion
of the workflow. Defaults to
``"{{ workflow.name }} completed successfully."``
.. attribute:: failure_message
A string which will be displayed to the user upon failure to complete
the workflow. Defaults to ``"{{ workflow.name }} did not complete."``
.. attribute:: depends_on
A roll-up list of all the ``depends_on`` values compiled from the
workflow's steps.
.. attribute:: contributions
A roll-up list of all the ``contributes`` values compiled from the
workflow's steps.
.. attribute:: template_name
Path to the template which should be used to render this workflow.
In general the default common template should be used. Default:
``"horizon/common/_workflow.html"``.
.. attribute:: entry_point
The slug of the step which should initially be active when the
workflow is rendered. This can be passed in upon initialization of
the workflow, or set anytime after initialization but before calling
either ``get_entry_point`` or ``render``.
.. attribute:: redirect_param_name
The name of a parameter used for tracking the URL to redirect to upon
completion of the workflow. Defaults to ``"next"``.
.. attribute:: object
The object (if any) which this workflow relates to. In the case of
a workflow which creates a new resource the object would be the created
resource after the relevant creation steps have been undertaken. In
the case of a workflow which updates a resource it would be the
resource being updated after it has been retrieved.
.. attribute:: wizard
Whether to present the workflow as a wizard, with "prev" and "next"
buttons and validation after every step.
"""
slug = None
default_steps = ()
template_name = "horizon/common/_workflow.html"
finalize_button_name = _("Save")
success_message = _("%s completed successfully.")
failure_message = _("%s did not complete.")
redirect_param_name = "next"
multipart = False
wizard = False
_registerable_class = Step
def __str__(self):
return self.name
def __repr__(self):
return "<%s: %s>" % (self.__class__.__name__, self.slug)
def __init__(self, request=None, context_seed=None, entry_point=None,
*args, **kwargs):
super(Workflow, self).__init__(*args, **kwargs)
if self.slug is None:
raise AttributeError("The workflow %s must have a slug."
% self.__class__.__name__)
self.name = getattr(self, "name", self.__class__.__name__)
self.request = request
self.depends_on = set([])
self.contributions = set([])
self.entry_point = entry_point
self.object = None
self._register_steps_from_config()
# Put together our steps in order. Note that we pre-register
# non-default steps so that we can identify them and subsequently
# insert them in order correctly.
self._registry = collections.OrderedDict(
[(step_class, step_class(self)) for step_class
in self.__class__._cls_registry
if step_class not in self.default_steps])
self._gather_steps()
# Determine all the context data we need to end up with.
for step in self.steps:
self.depends_on = self.depends_on | set(step.depends_on)
self.contributions = self.contributions | set(step.contributes)
# Initialize our context. For ease we can preseed it with a
# regular dictionary. This should happen after steps have been
# registered and ordered.
self.context = WorkflowContext(self)
context_seed = context_seed or {}
clean_seed = dict([(key, val)
for key, val in context_seed.items()
if key in self.contributions | self.depends_on])
self.context_seed = clean_seed
self.context.update(clean_seed)
if request and request.method == "POST":
for step in self.steps:
valid = step.action.is_valid()
# Be sure to use the CLEANED data if the workflow is valid.
if valid:
data = step.action.cleaned_data
else:
data = request.POST
self.context = step.contribute(data, self.context)
@property
def steps(self):
if getattr(self, "_ordered_steps", None) is None:
self._gather_steps()
return self._ordered_steps
def get_step(self, slug):
"""Returns the instantiated step matching the given slug."""
for step in self.steps:
if step.slug == slug:
return step
def _register_steps_from_config(self):
my_name = '.'.join([self.__class__.__module__,
self.__class__.__name__])
horizon_config = settings.HORIZON_CONFIG.get('extra_steps', {})
extra_steps = horizon_config.get(my_name, [])
for step in extra_steps:
self._register_step_from_config(step, my_name)
def _register_step_from_config(self, step_config, my_name):
if not isinstance(step_config, str):
LOG.error('Extra step definition must be a string '
'(workflow "%s"', my_name)
return
try:
class_ = module_loading.import_string(step_config)
except ImportError:
LOG.error('Step class "%s" is not found (workflow "%s")',
step_config, my_name)
return
self.register(class_)
def _gather_steps(self):
ordered_step_classes = self._order_steps()
for default_step in self.default_steps:
self.register(default_step)
self._registry[default_step] = default_step(self)
self._ordered_steps = []
for step_class in ordered_step_classes:
cls = self._registry[step_class]
if (has_permissions(self.request.user, cls) and
policy.check(cls.policy_rules, self.request) and
cls.allowed(self.request)):
self._ordered_steps.append(cls)
def _order_steps(self):
steps = list(copy.copy(self.default_steps))
additional = self._registry.keys()
for step in additional:
try:
min_pos = steps.index(step.after)
except ValueError:
min_pos = 0
try:
max_pos = steps.index(step.before)
except ValueError:
max_pos = len(steps)
if min_pos > max_pos:
raise exceptions.WorkflowError("The step %(new)s can't be "
"placed between the steps "
"%(after)s and %(before)s; the "
"step %(before)s comes before "
"%(after)s."
% {"new": additional,
"after": step.after,
"before": step.before})
steps.insert(max_pos, step)
return steps
def get_entry_point(self):
"""Returns the slug of the step which the workflow should begin on.
This method takes into account both already-available data and errors
within the steps.
"""
# If we have a valid specified entry point, use it.
if self.entry_point:
if self.get_step(self.entry_point):
return self.entry_point
# Otherwise fall back to calculating the appropriate entry point.
for step in self.steps:
if step.has_errors:
return step.slug
try:
step._verify_contributions(self.context)
except exceptions.WorkflowError:
return step.slug
# If nothing else, just return the first step.
return self.steps[0].slug
def _trigger_handlers(self, key):
responses = []
handlers = [(step.slug, f) for step in self.steps
for f in step._handlers.get(key, [])]
for slug, handler in handlers:
responses.append((slug, handler(self.request, self.context)))
return responses
@classmethod
def register(cls, step_class):
"""Registers a :class:`~horizon.workflows.Step` with the workflow."""
if not inspect.isclass(step_class):
raise ValueError('Only classes may be registered.')
elif not issubclass(step_class, cls._registerable_class):
raise ValueError('Only %s classes or subclasses may be registered.'
% cls._registerable_class.__name__)
if step_class in cls._cls_registry:
return False
else:
cls._cls_registry.append(step_class)
return True
@classmethod
def unregister(cls, step_class):
"""Unregisters a :class:`~horizon.workflows.Step` from the workflow."""
try:
cls._cls_registry.remove(step_class)
except ValueError:
raise base.NotRegistered('%s is not registered' % cls)
return cls._unregister(step_class)
def validate(self, context):
"""Hook for custom context data validation.
Should return a booleanvalue or
raise :class:`~horizon.exceptions.WorkflowValidationError`.
"""
return True
def is_valid(self):
"""Verifies that all required data is present in the context.
It also calls the ``validate`` method to allow for finer-grained checks
on the context data.
"""
missing = self.depends_on - set(self.context.keys())
if missing:
raise exceptions.WorkflowValidationError(
"Unable to complete the workflow. The values %s are "
"required but not present." % ", ".join(missing))
# Validate each step. Cycle through all of them to catch all errors
# in one pass before returning.
steps_valid = True
for step in self.steps:
if not step.action.is_valid():
steps_valid = False
step.has_errors = True
if not steps_valid:
return steps_valid
return self.validate(self.context)
def finalize(self):
"""Finalizes a workflow by running through all the actions.
It runs all the actions in order and calling their ``handle`` methods.
Returns ``True`` on full success, or ``False`` for a partial success,
e.g. there were non-critical errors.
(If it failed completely the function wouldn't return.)
"""
partial = False
for step in self.steps:
try:
data = step.action.handle(self.request, self.context)
if data is True or data is None:
continue
elif data is False:
partial = True
else:
self.context = step.contribute(data or {}, self.context)
except Exception:
partial = True
exceptions.handle(self.request)
if not self.handle(self.request, self.context):
partial = True
return not partial
def handle(self, request, context):
"""Handles any final processing for this workflow.
Should return a boolean value indicating success.
"""
return True
def get_success_url(self):
"""Returns a URL to redirect the user to upon completion.
By default it will attempt to parse a ``success_url`` attribute on the
workflow, which can take the form of a reversible URL pattern name,
or a standard HTTP URL.
"""
try:
return urls.reverse(self.success_url)
except urls.NoReverseMatch:
return self.success_url
def format_status_message(self, message):
"""Hook to allow customization of the message returned to the user.
This is called upon both successful or unsuccessful completion of
the workflow.
By default it simply inserts the workflow's name into the message
string.
"""
if "%s" in message:
return message % self.name
else:
return message
def verify_integrity(self):
provided_keys = self.contributions | set(self.context_seed.keys())
if len(self.depends_on - provided_keys):
raise exceptions.NotAvailable(
_("The current user has insufficient permission to complete "
"the requested task."))
def render(self):
"""Renders the workflow."""
workflow_template = template.loader.get_template(self.template_name)
extra_context = {"workflow": self}
if self.request.is_ajax():
extra_context['modal'] = True
return workflow_template.render(extra_context, self.request)
def get_absolute_url(self):
"""Returns the canonical URL for this workflow.
This is used for the POST action attribute on the form element
wrapping the workflow.
For convenience it defaults to the value of
``request.get_full_path()`` with any query string stripped off,
e.g. the path at which the workflow was requested.
"""
return self.request.get_full_path().partition('?')[0]
def add_error_to_step(self, message, slug):
"""Adds an error message to the workflow's Step.
This is useful when you wish for API errors to appear as errors
on the form rather than using the messages framework.
The workflow's Step is specified by its slug.
"""
step = self.get_step(slug)
if step:
step.add_step_error(message)
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals, print_function, absolute_import
try:
from urllib.parse import urlsplit
except ImportError:
from urlparse import urlsplit
from datetime import timedelta
from django.conf import settings as django_settings
from django.test import Client
from django.test import TestCase
from django.contrib.auth.models import User, update_last_login
from django.contrib.auth.signals import user_logged_in
from django.test.utils import override_settings as override_settings_orig
from django.core.urlresolvers import reverse
from django.core.exceptions import ImproperlyConfigured
from django.contrib.messages.storage.cookie import CookieStorage
from django.utils.six import text_type
from django.utils import timezone
from loginas import settings as la_settings
try:
import imp
reload = imp.reload # @ReservedAssignment
except ImportError:
pass
class override_settings(override_settings_orig):
"""
Reload application settings module every time we redefine a setting
"""
def enable(self):
super(override_settings, self).enable()
from loginas import settings as loginas_settings
reload(loginas_settings)
def disable(self):
super(override_settings, self).disable()
from loginas import settings as loginas_settings
reload(loginas_settings)
def create_user(username='', password='', **kwargs):
user = User(username=username, **kwargs)
if password:
user.set_password(password)
user.save()
return user
def login_as_nonstaff(request, user):
return request.user.is_superuser or (request.user.is_staff and
not user.is_staff)
class ViewTest(TestCase):
"""Tests for user_login view"""
def setUp(self):
self.client = Client(enforce_csrf_checks=True)
self.client.get('/') # To get the CSRF token for next request
assert django_settings.CSRF_COOKIE_NAME in self.client.cookies
self.target_user = User.objects.create(username='target')
# setup listener
user_logged_in.connect(update_last_login)
def tearDown(self):
"""Disconnect the listeners"""
user_logged_in.disconnect(update_last_login)
def get_csrf_token_payload(self):
return {
'csrfmiddlewaretoken':
self.client.cookies[django_settings.CSRF_COOKIE_NAME].value
}
def get_target_url(self, target_user=None):
if target_user is None:
target_user = self.target_user
response = self.client.post(
reverse("loginas-user-login", kwargs={'user_id': target_user.id}),
data=self.get_csrf_token_payload()
)
self.assertEqual(response.status_code, 302)
return response
def assertCurrentUserIs(self, user):
id_ = text_type(user.id if user is not None else None).encode('utf-8')
r = self.client.post(
reverse("current_user"),
data=self.get_csrf_token_payload()
)
self.assertEqual(r.content, id_)
def assertLoginError(self, resp):
self.assertEqual(urlsplit(resp['Location'])[2], "/")
messages = CookieStorage(resp)._decode(resp.cookies['messages'].value)
self.assertIn(
(40, "You do not have permission to do that."),
[(m.level, m.message) for m in messages]
)
def assertLoginSuccess(self, resp, user):
self.assertEqual(urlsplit(resp['Location'])[2],
django_settings.LOGIN_REDIRECT_URL)
msg = la_settings.MESSAGE_LOGIN_SWITCH.format(username=user.username)
messages = CookieStorage(resp)._decode(resp.cookies['messages'].value)
self.assertIn(msg, "".join([m.message for m in messages]))
def assertRaisesExact(self, exception, func, *args, **kwargs):
try:
func(*args, **kwargs)
self.assertFail("{0} not raised".format(exception))
except exception.__class__ as caught:
self.assertEqual(caught.args, exception.args)
def clear_session_cookie(self):
del self.client.cookies[django_settings.SESSION_COOKIE_NAME]
@override_settings(CAN_LOGIN_AS=login_as_nonstaff)
def test_custom_permissions(self):
user = create_user(u"üser", "pass", is_superuser=False, is_staff=False)
staff1 = create_user("stäff", "pass", is_superuser=False, is_staff=True)
staff2 = create_user("super", "pass", is_superuser=True, is_staff=True)
# Regular user can't login as anyone
self.assertTrue(self.client.login(username=u"üser", password="pass"))
self.assertLoginError(self.get_target_url())
self.assertCurrentUserIs(user)
self.clear_session_cookie()
# Non-superuser staff user can login as regular user
self.assertTrue(self.client.login(username="stäff", password="pass"))
response = self.get_target_url(user)
self.assertLoginSuccess(response, user)
self.assertCurrentUserIs(user)
self.clear_session_cookie()
# Non-superuser staff user cannot login as other staff
self.assertTrue(self.client.login(username="stäff", password="pass"))
self.assertLoginError(self.get_target_url(staff2))
self.assertCurrentUserIs(staff1)
self.clear_session_cookie()
# Superuser staff user can login as other staff
self.assertTrue(self.client.login(username="super", password="pass"))
response = self.get_target_url(staff1)
self.assertLoginSuccess(response, staff1)
self.assertCurrentUserIs(staff1)
@override_settings(CAN_LOGIN_AS='loginas.tests.login_as_shorter_username')
def test_custom_permissions_as_string(self):
ray = create_user("ray", "pass")
lonnie = create_user("lonnie", "pass")
# Ray cannot login as Lonnie
self.assertTrue(self.client.login(username="ray", password="pass"))
self.assertLoginError(self.get_target_url(lonnie))
self.assertCurrentUserIs(ray)
self.clear_session_cookie()
# Lonnie can login as Ray
self.assertTrue(self.client.login(username="lonnie", password="pass"))
response = self.get_target_url(ray)
self.assertLoginSuccess(response, ray)
self.assertCurrentUserIs(ray)
def test_custom_permissions_invalid_path(self):
def assertMessage(message):
self.assertRaisesExact(
ImproperlyConfigured(message),
self.get_target_url
)
with override_settings(CAN_LOGIN_AS='loginas.tests.invalid_func'):
assertMessage(
"Module loginas.tests does not define a invalid_func function.")
with override_settings(CAN_LOGIN_AS='loginas.tests.invalid_path.func'):
assertMessage("Error importing CAN_LOGIN_AS function: loginas.tests.invalid_path")
def test_as_superuser(self):
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="me", password="pass"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
self.assertCurrentUserIs(self.target_user)
def test_as_non_superuser(self):
user = create_user("me", "pass", is_staff=True)
self.assertTrue(self.client.login(username="me", password="pass"))
self.assertLoginError(self.get_target_url())
self.assertCurrentUserIs(user)
def test_as_anonymous_user(self):
self.assertLoginError(self.get_target_url())
self.assertCurrentUserIs(None)
def test_get_405_method_not_allowed(self):
url = reverse("loginas-user-login", kwargs={'user_id': '0'})
r = self.client.get(url)
self.assertEqual(r.status_code, 405)
def test_missing_csrf_token_403_forbidden(self):
url = reverse("loginas-user-login", kwargs={'user_id': '0'})
r = self.client.post(url)
self.assertEqual(r.status_code, 403)
@override_settings(LOGINAS_REDIRECT_URL="/another-redirect")
def test_loginas_redirect_url(self):
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="me", password="pass"))
response = self.client.post(
reverse("loginas-user-login", kwargs={'user_id': self.target_user.id}),
data=self.get_csrf_token_payload()
)
self.assertEqual(response.status_code, 302)
self.assertEqual(urlsplit(response['Location'])[2], "/another-redirect")
def test_restore_original_user(self):
# Create a super user and login as this
original_user = create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="me", password="pass"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
url = reverse("loginas-user-login", kwargs={'user_id': self.target_user.id})
self.client.get(url)
self.assertCurrentUserIs(self.target_user)
# Restore
url = reverse("loginas-logout")
self.client.get(url)
self.assertCurrentUserIs(original_user)
@override_settings(LOGINAS_LOGOUT_REDIRECT_URL="/another-redirect")
def test_loginas_redirect_url(self):
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="me", password="pass"))
response = self.client.get(reverse("loginas-logout"))
self.assertEqual(response.status_code, 302)
self.assertEqual(urlsplit(response['Location'])[2], "/another-redirect")
def test_last_login_not_updated(self):
last_login = timezone.now() - timedelta(hours=1)
self.target_user.last_login = last_login
self.target_user.save()
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="me", password="pass"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
self.assertCurrentUserIs(self.target_user)
target_user = User.objects.get(id=self.target_user.id) # refresh from db
self.assertEqual(target_user.last_login, last_login)
@override_settings(LOGINAS_UPDATE_LAST_LOGIN=True)
def test_last_login_updated(self):
last_login = timezone.now() - timedelta(hours=1)
self.target_user.last_login = last_login
self.target_user.save()
create_user("me", "pass", is_superuser=True, is_staff=True)
self.assertTrue(self.client.login(username="me", password="pass"))
response = self.get_target_url()
self.assertLoginSuccess(response, self.target_user)
self.assertCurrentUserIs(self.target_user)
target_user = User.objects.get(id=self.target_user.id) # refresh from db
self.assertGreater(target_user.last_login, last_login)
|
"""Module that provides classes that encapsulate model parts with states.
There are three classes: `Stateful`, `TemporalStateful`, and `SpatialStateful`.
Model parts that do not keep states in time but have a single tensor on the
output should be instances of `Stateful`. Model parts that keep their hidden
states in a time-oriented list (e.g. recurrent encoder) should be instances
of `TemporalStateful`. Model parts that keep the states in a 2D matrix (e.g.
image encoders) should be instances of `SpatialStateful`.
There are also classes that inherit from both stateful and temporal or spatial
stateful (e.g. `TemporalStatefulWithOutput`) that can be used for model parts
that satisfy more requirements (e.g. recurrent encoder).
"""
from abc import ABCMeta, abstractproperty
import tensorflow as tf
# pylint: disable=too-few-public-methods
# pydocstyle: disable=
class Stateful(metaclass=ABCMeta):
@abstractproperty
def output(self) -> tf.Tensor:
"""Return the object output.
A 2D `Tensor` of shape (batch, state_size) which contains the
resulting state of the object.
"""
raise NotImplementedError("Abstract property")
# pylint: enable=too-few-public-methods
class TemporalStateful(metaclass=ABCMeta):
@abstractproperty
def temporal_states(self) -> tf.Tensor:
"""Return object states in time.
A 3D `Tensor` of shape (batch, time, state_size) which contains the
states of the object in time (e.g. hidden states of a recurrent
encoder.
"""
raise NotImplementedError("Abstract property")
@abstractproperty
def temporal_mask(self) -> tf.Tensor:
"""Return mask for the temporal_states.
A 2D `Tensor` of shape (batch, time) of type float32 which masks the
temporal states so each sequence can have a different length. It should
only contain ones or zeros.
"""
raise NotImplementedError("Abstract property")
@property
def lengths(self) -> tf.Tensor:
"""Return the sequence lengths.
A 1D `Tensor` of type `int32` that stores the lengths of the
state sequences in the batch.
"""
return tf.to_int32(tf.reduce_sum(self.temporal_mask, 1))
@property
def dimension(self) -> int:
"""Return the dimension of the states."""
return self.temporal_states.get_shape()[-1].value
class SpatialStateful(metaclass=ABCMeta):
@property
def spatial_states(self) -> tf.Tensor:
"""Return object states in space.
A 4D `Tensor` of shape (batch, width, height, state_size) which
contains the states of the object in space (e.g. final layer of a
convolution network processing an image.
"""
raise NotImplementedError("Abstract property")
@abstractproperty
def spatial_mask(self) -> tf.Tensor:
"""Return mask for the spatial_states.
A 3D `Tensor` of shape (batch, width, height) of type float32
which masks the spatial states that they can be of different shapes.
The mask should only contain ones or zeros.
"""
raise NotImplementedError("Abstract property")
@property
def dimension(self) -> int:
"""Return the dimension of the states."""
return self.spatial_states.get_shape()[-1].value
# pylint: disable=abstract-method
class TemporalStatefulWithOutput(Stateful, TemporalStateful):
pass
class SpatialStatefulWithOutput(Stateful, SpatialStateful):
pass
|
# -*- coding: utf-8 -*-
import sys
import logging
import six
from six.moves import http_client
from redis import StrictRedis
import django
if django.VERSION[:2] >= (1, 7):
django.setup()
from django.conf import settings
from django.contrib.auth import get_user
from django.core.handlers.wsgi import WSGIRequest
from django.core.exceptions import PermissionDenied
from django import http
from django.utils.encoding import force_str
from django.utils.functional import SimpleLazyObject
from ws4redis import settings as private_settings
from ws4redis.redis_store import RedisMessage
from ws4redis.exceptions import WebSocketError, HandshakeError, UpgradeRequiredError
logger = logging.getLogger('django.request')
try:
# django >= 1.8 && python >= 2.7
# https://docs.djangoproject.com/en/1.8/releases/1.7/#django-utils-dictconfig-django-utils-importlib
from importlib import import_module
except ImportError:
# RemovedInDjango19Warning: django.utils.importlib will be removed in Django 1.9.
from django.utils.importlib import import_module
try:
# django >= 1.7
from django.utils.module_loading import import_string
except ImportError:
# django >= 1.5
from django.utils.module_loading import import_by_path as import_string
class WebsocketWSGIServer(object):
def __init__(self, redis_connection=None):
"""
redis_connection can be overriden by a mock object.
"""
comps = str(private_settings.WS4REDIS_SUBSCRIBER).split('.')
module = import_module('.'.join(comps[:-1]))
Subscriber = getattr(module, comps[-1])
self.possible_channels = Subscriber.subscription_channels + Subscriber.publish_channels
self._redis_connection = redis_connection and redis_connection or StrictRedis(**private_settings.WS4REDIS_CONNECTION)
self.Subscriber = Subscriber
self._websockets = set() # a list of currently active websockets
def assure_protocol_requirements(self, environ):
if environ.get('REQUEST_METHOD') != 'GET':
raise HandshakeError('HTTP method must be a GET')
if environ.get('SERVER_PROTOCOL') != 'HTTP/1.1':
raise HandshakeError('HTTP server protocol must be 1.1')
if environ.get('HTTP_UPGRADE', '').lower() != 'websocket':
raise HandshakeError('Client does not wish to upgrade to a websocket')
def process_request(self, request):
request.session = None
request.user = None
session_key = request.COOKIES.get(settings.SESSION_COOKIE_NAME, None)
if session_key is not None:
engine = import_module(settings.SESSION_ENGINE)
request.session = engine.SessionStore(session_key)
request.user = SimpleLazyObject(lambda: get_user(request))
def process_subscriptions(self, request):
agreed_channels = []
echo_message = False
for qp in request.GET:
param = qp.strip().lower()
if param in self.possible_channels:
agreed_channels.append(param)
elif param == 'echo':
echo_message = True
return agreed_channels, echo_message
@property
def websockets(self):
return self._websockets
def __call__(self, environ, start_response):
"""
Hijack the main loop from the original thread and listen on events on the Redis
and the Websocket filedescriptors.
"""
websocket = None
subscriber = self.Subscriber(self._redis_connection)
try:
self.assure_protocol_requirements(environ)
request = WSGIRequest(environ)
if isinstance(private_settings.WS4REDIS_PROCESS_REQUEST, six.string_types):
import_string(private_settings.WS4REDIS_PROCESS_REQUEST)(request)
elif callable(private_settings.WS4REDIS_PROCESS_REQUEST):
private_settings.WS4REDIS_PROCESS_REQUEST(request)
else:
self.process_request(request)
channels, echo_message = self.process_subscriptions(request)
if callable(private_settings.WS4REDIS_ALLOWED_CHANNELS):
channels = list(private_settings.WS4REDIS_ALLOWED_CHANNELS(request, channels))
elif private_settings.WS4REDIS_ALLOWED_CHANNELS is not None:
try:
mod, callback = private_settings.WS4REDIS_ALLOWED_CHANNELS.rsplit('.', 1)
callback = getattr(import_module(mod), callback, None)
if callable(callback):
channels = list(callback(request, channels))
except AttributeError:
pass
websocket = self.upgrade_websocket(environ, start_response)
self._websockets.add(websocket)
logger.debug('Subscribed to channels: {0}'.format(', '.join(channels)))
subscriber.set_pubsub_channels(request, channels)
websocket_fd = websocket.get_file_descriptor()
listening_fds = [websocket_fd]
redis_fd = subscriber.get_file_descriptor()
if redis_fd:
listening_fds.append(redis_fd)
subscriber.send_persisted_messages(websocket)
recvmsg = None
while websocket and not websocket.closed:
ready = self.select(listening_fds, [], [], 4.0)[0]
if not ready:
# flush empty socket
websocket.flush()
for fd in ready:
if fd == websocket_fd:
recvmsg = RedisMessage(websocket.receive())
if recvmsg:
subscriber.publish_message(recvmsg)
elif fd == redis_fd:
sendmsg = RedisMessage(subscriber.parse_response())
if sendmsg and (echo_message or sendmsg != recvmsg):
websocket.send(sendmsg)
else:
logger.error('Invalid file descriptor: {0}'.format(fd))
# Check again that the websocket is closed before sending the heartbeat,
# because the websocket can closed previously in the loop.
if private_settings.WS4REDIS_HEARTBEAT and not websocket.closed:
websocket.send(private_settings.WS4REDIS_HEARTBEAT)
# Remove websocket from _websockets if closed
if websocket.closed:
self._websockets.remove(websocket)
except WebSocketError as excpt:
logger.warning('WebSocketError: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponse(content='Websocket Closed')
# bypass status code validation in HttpResponse constructor -- necessary for Django v1.11
response.status_code = 1001
except UpgradeRequiredError as excpt:
logger.info('Websocket upgrade required')
response = http.HttpResponseBadRequest(status=426, content=excpt)
except HandshakeError as excpt:
logger.warning('HandshakeError: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponseBadRequest(content=excpt)
except PermissionDenied as excpt:
logger.warning('PermissionDenied: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponseForbidden(content=excpt)
except Exception as excpt:
logger.error('Other Exception: {}'.format(excpt), exc_info=sys.exc_info())
response = http.HttpResponseServerError(content=excpt)
else:
response = http.HttpResponse()
finally:
subscriber.release()
if websocket:
websocket.close(code=1001, message='Websocket Closed')
else:
logger.warning('Starting late response on websocket')
status_text = http_client.responses.get(response.status_code, 'UNKNOWN STATUS CODE')
status = '{0} {1}'.format(response.status_code, status_text)
headers = response._headers.values()
if six.PY3:
headers = list(headers)
start_response(force_str(status), headers)
logger.info('Finish non-websocket response with status code: {}'.format(response.status_code))
return response
|
# Copyright 2017 FUJITSU LIMITED
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
from osc_lib.command import command
from osc_lib import exceptions
from osc_lib import utils
from osc_lib.utils import columns as column_util
from oslo_log import log as logging
from neutronclient._i18n import _
from neutronclient.common import utils as nc_utils
from neutronclient.osc import utils as osc_utils
from neutronclient.osc.v2.vpnaas import utils as vpn_utils
LOG = logging.getLogger(__name__)
_attr_map = (
('id', 'ID', column_util.LIST_BOTH),
('name', 'Name', column_util.LIST_BOTH),
('auth_algorithm', 'Authentication Algorithm', column_util.LIST_BOTH),
('encryption_algorithm', 'Encryption Algorithm', column_util.LIST_BOTH),
('ike_version', 'IKE Version', column_util.LIST_BOTH),
('pfs', 'Perfect Forward Secrecy (PFS)', column_util.LIST_BOTH),
('description', 'Description', column_util.LIST_LONG_ONLY),
('phase1_negotiation_mode', 'Phase1 Negotiation Mode',
column_util.LIST_LONG_ONLY),
('tenant_id', 'Project', column_util.LIST_LONG_ONLY),
('lifetime', 'Lifetime', column_util.LIST_LONG_ONLY),
)
def _convert_to_lowercase(string):
return string.lower()
def _get_common_parser(parser):
parser.add_argument(
'--description',
metavar='<description>',
help=_('Description of the IKE policy'))
parser.add_argument(
'--auth-algorithm',
choices=['sha1', 'sha256', 'sha384', 'sha512'],
type=_convert_to_lowercase,
help=_('Authentication algorithm'))
parser.add_argument(
'--encryption-algorithm',
choices=['aes-128', '3des', 'aes-192', 'aes-256'],
type=_convert_to_lowercase,
help=_('Encryption algorithm'))
parser.add_argument(
'--phase1-negotiation-mode',
choices=['main', 'aggressive'],
type=_convert_to_lowercase,
help=_('IKE Phase1 negotiation mode'))
parser.add_argument(
'--ike-version',
choices=['v1', 'v2'],
type=_convert_to_lowercase,
help=_('IKE version for the policy'))
parser.add_argument(
'--pfs',
choices=['group5', 'group2', 'group14'],
type=_convert_to_lowercase,
help=_('Perfect Forward Secrecy'))
parser.add_argument(
'--lifetime',
metavar="units=UNITS,value=VALUE",
type=nc_utils.str2dict_type(optional_keys=['units', 'value']),
help=vpn_utils.lifetime_help("IKE"))
return parser
def _get_common_attrs(client_manager, parsed_args, is_create=True):
attrs = {}
if is_create:
if 'project' in parsed_args and parsed_args.project is not None:
attrs['tenant_id'] = osc_utils.find_project(
client_manager.identity,
parsed_args.project,
parsed_args.project_domain,
).id
if parsed_args.description:
attrs['description'] = parsed_args.description
if parsed_args.auth_algorithm:
attrs['auth_algorithm'] = parsed_args.auth_algorithm
if parsed_args.encryption_algorithm:
attrs['encryption_algorithm'] = parsed_args.encryption_algorithm
if parsed_args.phase1_negotiation_mode:
attrs['phase1_negotiation_mode'] = parsed_args.phase1_negotiation_mode
if parsed_args.ike_version:
attrs['ike_version'] = parsed_args.ike_version
if parsed_args.pfs:
attrs['pfs'] = parsed_args.pfs
if parsed_args.lifetime:
vpn_utils.validate_lifetime_dict(parsed_args.lifetime)
attrs['lifetime'] = parsed_args.lifetime
return attrs
class CreateIKEPolicy(command.ShowOne):
_description = _("Create an IKE policy")
def get_parser(self, prog_name):
parser = super(CreateIKEPolicy, self).get_parser(prog_name)
_get_common_parser(parser)
parser.add_argument(
'name',
metavar='<name>',
help=_('Name of the IKE policy'))
osc_utils.add_project_owner_option_to_parser(parser)
return parser
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_common_attrs(self.app.client_manager, parsed_args)
if parsed_args.name:
attrs['name'] = str(parsed_args.name)
obj = client.create_ikepolicy({'ikepolicy': attrs})['ikepolicy']
columns, display_columns = column_util.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
class DeleteIKEPolicy(command.Command):
_description = _("Delete IKE policy (policies)")
def get_parser(self, prog_name):
parser = super(DeleteIKEPolicy, self).get_parser(prog_name)
parser.add_argument(
'ikepolicy',
metavar='<ike-policy>',
nargs='+',
help=_('IKE policy to delete (name or ID)'))
return parser
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
result = 0
for ike in parsed_args.ikepolicy:
try:
ike_id = client.find_resource(
'ikepolicy', ike, cmd_resource='ikepolicy')['id']
client.delete_ikepolicy(ike_id)
except Exception as e:
result += 1
LOG.error(_("Failed to delete IKE policy with "
"name or ID '%(ikepolicy)s': %(e)s"),
{'ikepolicy': ike, 'e': e})
if result > 0:
total = len(parsed_args.ikepolicy)
msg = (_("%(result)s of %(total)s IKE policy failed "
"to delete.") % {'result': result, 'total': total})
raise exceptions.CommandError(msg)
class ListIKEPolicy(command.Lister):
_description = _("List IKE policies that belong to a given project")
def get_parser(self, prog_name):
parser = super(ListIKEPolicy, self).get_parser(prog_name)
parser.add_argument(
'--long',
action='store_true',
help=_("List additional fields in output")
)
return parser
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
obj = client.list_ikepolicies()['ikepolicies']
headers, columns = column_util.get_column_definitions(
_attr_map, long_listing=parsed_args.long)
return (headers, (utils.get_dict_properties(s, columns) for s in obj))
class SetIKEPolicy(command.Command):
_description = _("Set IKE policy properties")
def get_parser(self, prog_name):
parser = super(SetIKEPolicy, self).get_parser(prog_name)
_get_common_parser(parser)
parser.add_argument(
'--name',
metavar='<name>',
help=_('Name of the IKE policy'))
parser.add_argument(
'ikepolicy',
metavar='<ike-policy>',
help=_('IKE policy to set (name or ID)'))
return parser
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_common_attrs(self.app.client_manager,
parsed_args, is_create=False)
if parsed_args.name:
attrs['name'] = parsed_args.name
ike_id = client.find_resource(
'ikepolicy', parsed_args.ikepolicy,
cmd_resource='ikepolicy')['id']
try:
client.update_ikepolicy(ike_id, {'ikepolicy': attrs})
except Exception as e:
msg = (_("Failed to set IKE policy '%(ike)s': %(e)s")
% {'ike': parsed_args.ikepolicy, 'e': e})
raise exceptions.CommandError(msg)
class ShowIKEPolicy(command.ShowOne):
_description = _("Display IKE policy details")
def get_parser(self, prog_name):
parser = super(ShowIKEPolicy, self).get_parser(prog_name)
parser.add_argument(
'ikepolicy',
metavar='<ike-policy>',
help=_('IKE policy to display (name or ID)'))
return parser
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
ike_id = client.find_resource(
'ikepolicy', parsed_args.ikepolicy,
cmd_resource='ikepolicy')['id']
obj = client.show_ikepolicy(ike_id)['ikepolicy']
columns, display_columns = column_util.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return (display_columns, data)
|
# main script file run by VoxelCut
from vc import *
import wx
import math
voxels_per_mm = float(0)
x = float(0)
y = float(0)
z = float(0)
rad = float(0)
def jump_to(nx, ny, nz):
global x
global y
global z
x, y, z = nx, ny, nz
def get_voxel_pos(nx, ny, nz):
global voxels_per_mm
vx = int(512 - 300 + nx * voxels_per_mm+0.5)
vy = int(512 - 300 + ny * voxels_per_mm+0.5)
vz = int(256 + (-10 - nz) * voxels_per_mm+0.5)
return vx, vy, vz
def subtract_tool_at(nx, ny, nz):
global rad
global voxels_per_mm
vx, vy, vz = get_voxel_pos(nx, ny, nz)
vrad = int(rad * voxels_per_mm)
setcylinder(vx, vy, vz, vx, vy, 0, vrad, -1)
def cut_to(nx, ny, nz):
global x
global y
global z
vx = float(nx) - x
vy = float(ny) - y
vz = float(nz) - z
magn = math.sqrt(vx*vx + vy*vy + vz*vz)
voxmagn = magn*voxels_per_mm
num_steps = int(voxmagn + 0.9)
for i in range(0, num_steps):
fraction = float(i+1)/num_steps
tx = x + fraction * vx
ty = y + fraction * vy
tz = z + fraction * vz
subtract_tool_at(tx, ty, tz)
repaint()
x, y, z = nx, ny, nz
def get_value(s, name):
# gets a value from the string, like: found, x = get_value('N1000G0X4.56Y34.78M6', 'X'), gives found = true, x = 4.56
pos = s.find(name)
if pos == -1: return False, 0.0
numstr = ''
for x in range(pos + 1, len(s)):
if s[x].isdigit() or s[x] == '.' or s[x] == '-':
numstr = numstr + s[x]
else: break
if len(numstr) == 0: return False, 0.0
return True, float(numstr)
def read_nc_file(fpath):
# set the tool position to z50mm
jump_to(0, 0, 50)
# set a tool diameter of 3mm
global rad
rad = 1.5
# open the nc file
f = open(fpath)
global x
global y
global z
nx = x
ny = y
nz = z
while (True):
line = f.readline()
if (len(line) == 0) : break
G0_found = (line.find('G0') != -1)
G1_found = (line.find('G1') != -1)
G2_found = (line.find('G2') != -1)
G3_found = (line.find('G3') != -1)
X_found, tx = get_value(line, 'X')
Y_found, ty = get_value(line, 'Y')
Z_found, tz = get_value(line, 'Z')
move_found = False
if X_found:
nx = tx
move_found = True
if Y_found:
ny = ty
move_found = True
if Z_found:
nz = tz
move_found = True
if move_found:
cut_to(nx, ny, nz)
f.close()
# clear the volume
setrect(0, 0, 0, 1024, 1024, 256, -1)
repaint()
# make a default block 50mm x 50mm x 10mm
global voxels_per_mm
vwidth = 600
mwidth = 50
voxels_per_mm = vwidth/mwidth
x0 = 512 - 300
y0 = 512 - 300
z0 = 256 - 10 * voxels_per_mm
x1 = 512 + 300
y1 = 512 + 300
z1 = 256
setrect(x0, y0, z0, x1, y1, z1, 0)
repaint()
# ask the user to choose an nc file
app = wx.App()
fd = wx.FileDialog(None, "Open NC File", "", "", "Tap Files (*.tap)|*.tap")
result = fd.ShowModal()
if result == wx.ID_OK:
read_nc_file(fd.GetPath())
|
from django.conf import settings
from .account.serializers import (
UserDetailsSerializer as DefaultUserDetailsSerializer,
LoginSerializer as DefaultLoginSerializer,
ChangePasswordSerializer as DefaultChangePasswordSerializer,
SetPasswordSerializer as DefaultSetPasswordSerializer,
EmailSerializer as DefaultEmailSerializer,
ConfirmEmailSerializer as DefaultConfirmEmailSerializer,
ResetPasswordSerializer as DefaultResetPasswordSerializer,
ResetPasswordKeySerializer as DefaultPasswordResetConfirmSerializer,
)
from .serializers import (
TokenSerializer as DefaultTokenSerializer,
)
from .utils import import_callable
serializers = getattr(settings, 'REST_AUTH_SERIALIZERS', {})
UserDetailsSerializer = import_callable(
serializers.get('USER_DETAILS_SERIALIZER', DefaultUserDetailsSerializer)
)
LoginSerializer = import_callable(
serializers.get('LOGIN_SERIALIZER', DefaultLoginSerializer)
)
ChangePasswordSerializer = import_callable(
serializers.get('PASSWORD_CHANGE_SERIALIZER', DefaultChangePasswordSerializer)
)
SetPasswordSerializer = import_callable(
serializers.get('PASSWORD_SET_SERIALIZER', DefaultSetPasswordSerializer)
)
EmailSerializer = import_callable(
serializers.get('EMAIL_SERIALIZER', DefaultEmailSerializer)
)
ConfirmEmailSerializer = import_callable(
serializers.get('CONFIRM_EMAIL_SERIALIZER', DefaultConfirmEmailSerializer)
)
ResetPasswordSerializer = import_callable(
serializers.get('PASSWORD_RESET_SERIALIZER', DefaultResetPasswordSerializer)
)
ResetPasswordKeySerializer = import_callable(
serializers.get('PASSWORD_RESET_CONFIRM_SERIALIZER', DefaultPasswordResetConfirmSerializer)
)
TokenSerializer = import_callable(
serializers.get('TOKEN_SERIALIZER', DefaultTokenSerializer)
)
|
# -*- coding: UTF-8 -*-
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from meregistro.shortcuts import my_render
from apps.seguridad.decorators import login_required, credential_required
from apps.titulos.models import CarreraJurisdiccional, Cohorte, CohorteEstablecimiento, EstadoCarreraJurisdiccional, EstadoCohorteEstablecimiento, \
CohorteAnexo, EstadoCohorteAnexo, CohorteExtensionAulica, \
EstadoCohorteExtensionAulica, CarreraJurisdiccionalCohorte
from apps.titulos.forms import CarreraJurisdiccionalCohorteFormFilters, CohorteForm, CohorteAsignarEstablecimientosFormFilters, \
CohorteAsignarAnexosFormFilters, CohorteAsignarExtensionesAulicasFormFilters
from apps.registro.models import Jurisdiccion, Establecimiento
from django.core.paginator import Paginator
from helpers.MailHelper import MailHelper
import datetime
from apps.reportes.views.cohorte_jurisdiccional import cohortes_jurisdiccionales as reporte_cohortes_jurisdiccionales
from apps.reportes.models import Reporte
ITEMS_PER_PAGE = 50
def build_query(filters, page, request):
"""
Construye el query de búsqueda a partir de los filtros.
"""
if filters.jur:
q = filters.buildQuery().order_by('carrera__nombre')
else:
q = filters.buildQuery().order_by('jurisdiccion__nombre', 'carrera__nombre')
return q
@login_required
@credential_required('tit_cohorte_consulta')
def index(request):
"""
Búsqueda de titulos
"""
jur = request.get_perfil().jurisdiccion()
if request.method == 'GET':
form_filter = CarreraJurisdiccionalCohorteFormFilters(request.GET, jurisdiccion=jur)
else:
form_filter = CarreraJurisdiccionalCohorteFormFilters(jurisdiccion=jur)
q = build_query(form_filter, 1, request)
try:
if request.GET['export'] == '1':
return reporte_cohortes_jurisdiccionales(request, q)
except KeyError:
pass
paginator = Paginator(q, ITEMS_PER_PAGE)
try:
page_number = int(request.GET['page'])
except (KeyError, ValueError):
page_number = 1
# chequear los límites
if page_number < 1:
page_number = 1
elif page_number > paginator.num_pages:
page_number = paginator.num_pages
page = paginator.page(page_number)
objects = page.object_list
return my_render(request, 'titulos/cohorte/index.html', {
'form_filters': form_filter,
'objects': objects,
'paginator': paginator,
'page': page,
'page_number': page_number,
'pages_range': range(1, paginator.num_pages + 1),
'next_page': page_number + 1,
'prev_page': page_number - 1,
'export_url': Reporte.build_export_url(request.build_absolute_uri()),
})
@login_required
#@credential_required('tit_cohorte_alta')
def create(request, carrera_jurisdiccional_id):
"""
Alta de cohorte
"""
carrera_jurisdiccional = CarreraJurisdiccional.objects.get(pk=carrera_jurisdiccional_id)
if request.method == 'POST':
form = CohorteForm(request.POST)
if form.is_valid():
cohorte = form.save()
# redirigir a edit
request.set_flash('success', 'Datos guardados correctamente.')
return HttpResponseRedirect(reverse('cohortesPorCarreraJurisdiccional', args=[carrera_jurisdiccional.id]))
else:
request.set_flash('warning', 'Ocurrió un error guardando los datos.')
else:
form = CohorteForm()
choices = [('', '-------')]
"""
try:
for cohorte in carrera_jurisdiccional.datos_cohorte.all():
choices += [(i, i) for i in range(cohorte.primera_cohorte_solicitada, cohorte.ultima_cohorte_solicitada + 1)]
except CarreraJurisdiccionalCohorte.DoesNotExist:
pass
form.fields["anio"].choices = choices
"""
form.fields["carrera_jurisdiccional"].initial = carrera_jurisdiccional.id
return my_render(request, 'titulos/cohorte/new.html', {
'form': form,
'carrera_jurisdiccional': carrera_jurisdiccional,
'is_new': True,
})
@login_required
#@credential_required('tit_cohorte_modificar')
# Editar datos básicos
def edit(request, cohorte_id):
"""
Edición de los datos de una cohorte.
"""
cohorte = Cohorte.objects.get(pk=cohorte_id)
if request.method == 'POST':
form = CohorteForm(request.POST, instance=cohorte)
if form.is_valid():
cohorte = form.save()
request.set_flash('success', 'Datos actualizados correctamente.')
else:
request.set_flash('warning', 'Ocurrió un error actualizando los datos.')
else:
form = CohorteForm(instance=cohorte)
carrera_jurisdiccional = cohorte.carrera_jurisdiccional
"""
choices = []
for a_cohorte in carrera_jurisdiccional.datos_cohorte.all():
choices += [(i, i) for i in range(a_cohorte.primera_cohorte_solicitada, a_cohorte.ultima_cohorte_solicitada + 1)]
form.fields["anio"].choices = choices
"""
asignada_establecimiento = cohorte.asignada_establecimiento()
if asignada_establecimiento:
form.fields["anio"].choices = [(cohorte.anio, cohorte.anio)]
# No se puede modificar la carrera ni el año
form.fields["carrera_jurisdiccional"].queryset = CarreraJurisdiccional.objects.filter(id=cohorte.carrera_jurisdiccional_id)
form.fields["carrera_jurisdiccional"].empty_label = None
return my_render(request, 'titulos/cohorte/edit.html', {
'form': form,
'cohorte': cohorte,
'carrera_jurisdiccional': cohorte.carrera_jurisdiccional,
'asignada_establecimiento': asignada_establecimiento,
'is_new': False,
})
@login_required
@credential_required('tit_cohorte_consulta')
def cohortes_por_carrera_jurisdiccional(request, carrera_jurisdiccional_id):
"Cohortes por título"
carrera_jurisdiccional = CarreraJurisdiccional.objects.get(pk=carrera_jurisdiccional_id)
q = Cohorte.objects.filter(carrera_jurisdiccional__id=carrera_jurisdiccional.id)
paginator = Paginator(q, ITEMS_PER_PAGE)
try:
page_number = int(request.GET['page'])
except (KeyError, ValueError):
page_number = 1
# chequear los límites
if page_number < 1:
page_number = 1
elif page_number > paginator.num_pages:
page_number = paginator.num_pages
page = paginator.page(page_number)
objects = page.object_list
return my_render(request, 'titulos/cohorte/cohortes_por_carrera_jurisdiccional.html', {
#'form_filters': form_filter,
'carrera_jurisdiccional': carrera_jurisdiccional,
'objects': objects,
'paginator': paginator,
'page': page,
'page_number': page_number,
'pages_range': range(1, paginator.num_pages + 1),
'next_page': page_number + 1,
'prev_page': page_number - 1
})
@login_required
@credential_required('tit_cohorte_asignar')
def asignar_establecimientos(request, cohorte_id):
"""
Asignar cohorte a establecimientos
"""
cohorte = Cohorte.objects.get(pk=cohorte_id)
"Traigo los ids de los establecimientos actualmente asignados a la cohorte"
current_establecimientos_ids = __flat_list(CohorteEstablecimiento.objects.filter(cohorte=cohorte).values_list("establecimiento_id"))
"Búsqueda de establecimientos"
" Siempre lo hago en base a GET ya que cuando mando por POST no tiene cuenta el filtro y KABOOM! #483"
form_filters = CohorteAsignarEstablecimientosFormFilters(request.GET)
jurisdiccion = request.get_perfil().jurisdiccion()
form_filters.fields["dependencia_funcional"].queryset = form_filters.fields["dependencia_funcional"].queryset.filter(jurisdiccion=jurisdiccion)
q = build_asignar_establecimientos_query(form_filters, request)
q1 = q.filter(id__in=current_establecimientos_ids).order_by('cue') # seleccionados
q2 = q.exclude(id__in=[e.id for e in q1]).order_by('cue') # no seleccionados
from itertools import chain
res = list(chain(q1, q2))
paginator = Paginator(res, ITEMS_PER_PAGE)
try:
page_number = int(request.GET['page'])
except (KeyError, ValueError):
page_number = 1
# chequear los límites
if page_number < 1:
page_number = 1
elif page_number > paginator.num_pages:
page_number = paginator.num_pages
page = paginator.page(page_number)
objects = page.object_list
"Procesamiento"
if request.method == 'POST':
estado = EstadoCohorteEstablecimiento.objects.get(nombre=EstadoCohorteEstablecimiento.ASIGNADA)
values_dict = {
'establecimientos_procesados_ids': [e.id for e in objects], # Son los establecimientos de la página actual
'current_establecimientos_ids': current_establecimientos_ids,
'establecimientos_seleccionados_ids': request.POST.getlist("establecimientos"),
'estado': estado,
}
cohorte.save_establecimientos(**values_dict)
request.set_flash('success', 'Datos actualizados correctamente.')
# redirigir a edit
return HttpResponseRedirect(reverse('cohorteAsignarEstablecimientos', args=[cohorte.id]))
return my_render(request, 'titulos/cohorte/asignar_establecimientos.html', {
'cohorte': cohorte,
'current_establecimientos_ids': current_establecimientos_ids,
'form_filters': form_filters,
'objects': objects,
'paginator': paginator,
'page': page,
'page_number': page_number,
'pages_range': range(1, paginator.num_pages + 1),
'next_page': page_number + 1,
'prev_page': page_number - 1
})
def build_asignar_establecimientos_query(filters, request):
"""
Construye el query de búsqueda a partir de los filtros.
"""
return filters.buildQuery().filter(ambito__path__istartswith=request.get_perfil().ambito.path)
@login_required
@credential_required('tit_cohorte_asignar')
def asignar_anexos(request, cohorte_id):
"""
Asignar cohorte a anexos
"""
cohorte = Cohorte.objects.get(pk=cohorte_id)
"Traigo los ids de los anexos actualmente asignados a la cohorte"
current_anexos_ids = __flat_list(CohorteAnexo.objects.filter(cohorte=cohorte).values_list("anexo_id"))
"Búsqueda de anexos"
" Siempre lo hago en base a GET ya que cuando mando por POST no tiene cuenta el filtro y KABOOM! #483"
form_filters = CohorteAsignarAnexosFormFilters(request.GET)
jurisdiccion = request.get_perfil().jurisdiccion()
form_filters.fields["dependencia_funcional"].queryset = form_filters.fields["dependencia_funcional"].queryset.filter(jurisdiccion=jurisdiccion)
q = build_asignar_anexos_query(form_filters, request)
q1 = q.filter(id__in=current_anexos_ids).order_by('cue') # seleccionados
q2 = q.exclude(id__in=[a.id for a in q1]).order_by('cue') # no seleccionados
from itertools import chain
res = list(chain(q1, q2))
paginator = Paginator(res, ITEMS_PER_PAGE)
try:
page_number = int(request.GET['page'])
except (KeyError, ValueError):
page_number = 1
# chequear los límites
if page_number < 1:
page_number = 1
elif page_number > paginator.num_pages:
page_number = paginator.num_pages
page = paginator.page(page_number)
objects = page.object_list
"Procesamiento"
if request.method == 'POST':
estado = EstadoCohorteAnexo.objects.get(nombre=EstadoCohorteAnexo.ASIGNADA)
values_dict = {
'anexos_procesados_ids': [a.id for a in objects], # Son los anexos de la página actual
'current_anexos_ids': current_anexos_ids,
'anexos_seleccionados_ids': request.POST.getlist("anexos"),
'estado': estado,
}
cohorte.save_anexos(**values_dict)
request.set_flash('success', 'Datos actualizados correctamente.')
# redirigir a edit
return HttpResponseRedirect(reverse('cohorteAsignarAnexos', args=[cohorte.id]))
return my_render(request, 'titulos/cohorte/asignar_anexos.html', {
'cohorte': cohorte,
'current_anexos_ids': current_anexos_ids,
'form_filters': form_filters,
'objects': objects,
'paginator': paginator,
'page': page,
'page_number': page_number,
'pages_range': range(1, paginator.num_pages + 1),
'next_page': page_number + 1,
'prev_page': page_number - 1
})
def build_asignar_anexos_query(filters, request):
"""
Construye el query de búsqueda a partir de los filtros.
"""
return filters.buildQuery().filter(ambito__path__istartswith=request.get_perfil().ambito.path).order_by('nombre')
@login_required
@credential_required('tit_cohorte_asignar')
def asignar_extensiones_aulicas(request, cohorte_id):
"""
Asignar cohorte a extensiones áulicas
"""
cohorte = Cohorte.objects.get(pk=cohorte_id)
"Traigo los ids de las extensiones áulicas actualmente asignados a la cohorte"
current_extensiones_aulicas_ids = __flat_list(CohorteExtensionAulica.objects.filter(cohorte=cohorte).values_list("extension_aulica_id"))
"Búsqueda de extensiones áulicas"
" Siempre lo hago en base a GET ya que cuando mando por POST no tiene cuenta el filtro y KABOOM! #483"
form_filters = CohorteAsignarExtensionesAulicasFormFilters(request.GET)
jurisdiccion = request.get_perfil().jurisdiccion()
form_filters.fields["dependencia_funcional"].queryset = form_filters.fields["dependencia_funcional"].queryset.filter(jurisdiccion=jurisdiccion)
q = build_asignar_extensiones_aulicas_query(form_filters, request)
q1 = q.filter(id__in=current_extensiones_aulicas_ids).order_by('cue') # seleccionados
q2 = q.exclude(id__in=[ea.id for ea in q1]).order_by('cue') # no seleccionados
from itertools import chain
res = list(chain(q1, q2))
paginator = Paginator(res, ITEMS_PER_PAGE)
try:
page_number = int(request.GET['page'])
except (KeyError, ValueError):
page_number = 1
# chequear los límites
if page_number < 1:
page_number = 1
elif page_number > paginator.num_pages:
page_number = paginator.num_pages
page = paginator.page(page_number)
objects = page.object_list
"Procesamiento"
if request.method == 'POST':
estado = EstadoCohorteExtensionAulica.objects.get(nombre=EstadoCohorteExtensionAulica.ASIGNADA)
values_dict = {
'extensiones_aulicas_procesadas_ids': [e.id for e in objects], # Son las extensiones de la página actual
'current_extensiones_aulicas_ids': current_extensiones_aulicas_ids,
'extensiones_aulicas_seleccionadas_ids': request.POST.getlist("extensiones_aulicas"),
'estado': estado,
}
cohorte.save_extensiones_aulicas(**values_dict)
request.set_flash('success', 'Datos actualizados correctamente.')
# redirigir a edit
return HttpResponseRedirect(reverse('cohorteAsignarExtensionesAulicas', args=[cohorte.id]))
return my_render(request, 'titulos/cohorte/asignar_extensiones_aulicas.html', {
'cohorte': cohorte,
'current_extensiones_aulicas_ids': current_extensiones_aulicas_ids,
'form_filters': form_filters,
'objects': objects,
'paginator': paginator,
'page': page,
'page_number': page_number,
'pages_range': range(1, paginator.num_pages + 1),
'next_page': page_number + 1,
'prev_page': page_number - 1
})
def build_asignar_extensiones_aulicas_query(filters, request):
"""
Construye el query de búsqueda a partir de los filtros.
"""
return filters.buildQuery().filter(establecimiento__ambito__path__istartswith=request.get_perfil().ambito.path)
@login_required
@credential_required('tit_cohorte_eliminar')
def eliminar(request, cohorte_id):
"""
Baja de una cohorte
--- mientras no estén asignadas a un establecimiento ---
"""
cohorte = Cohorte.objects.get(pk=cohorte_id)
asignada_establecimiento = cohorte.asignada_establecimiento()
if asignada_establecimiento:
request.set_flash('warning', 'La cohorte no puede darse de baja porque tiene establecimientos asignados.')
else:
request.set_flash('warning', 'Está seguro de eliminar la cohorte? Esta operación no puede deshacerse.')
if request.method == 'POST':
if int(request.POST['cohorte_id']) is not int(cohorte.id):
raise Exception('Error en la consulta!')
cohorte.delete()
request.set_flash('success', 'La cohorte fue eliminada correctamente.')
""" Redirecciono para evitar el reenvío del form """
return HttpResponseRedirect(reverse('cohorte'))
return my_render(request, 'titulos/cohorte/eliminar.html', {
'cohorte': cohorte,
'cohorte_id': cohorte.id,
'asignada_establecimiento': asignada_establecimiento,
})
def __flat_list(list_to_flat):
"Método para aplanar las listas"
return [i for j in list_to_flat for i in j]
@login_required
#@credential_required('revisar_jurisdiccion')
def revisar_jurisdiccion(request, oid):
o = Cohorte.objects.get(pk=oid)
o.revisado_jurisdiccion = True
o.save()
request.set_flash('success', 'Registro revisado.')
return HttpResponseRedirect(reverse('cohortesPorTitulo', args=[o.carrera_jurisdiccional_id]))
|
from PIL import Image
import numpy as np
import h5py
import os
import sys
import cv2
# Maybe consider implemeting more involved auto-balancing
# http://wiki.cmci.info/documents/120206pyip_cooking/python_imagej_cookbook#automatic_brightnesscontrast_button
def open(fn):
print "Opening " + fn
ext = os.path.splitext(fn)
if ext == '.h5':
f = h5py.File(fn, 'r')
img = f['/img']
return np.array(img)
else:
img = Image.open(fn)
return np.array(img)
def write_to_h5(fn, arr):
"""Write ndarray to H5 file under group "main"
"""
print "Writing to " + fn
sz = np.asarray(arr.shape)
f = h5py.File(fn, "w")
f.create_dataset("/img", data=arr.T, dtype=arr.dtype)
f.create_dataset("/size", data=sz, dtype=sz.dtype)
f.close()
def main(src_dir, dst_dir):
"""Make H5 files of all TIF images in directory
"""
# src_dir = "/media/tmacrina/667FB0797A5072D7/3D_align"
# dst_dir = "/media/tmacrina/4BED39E032CF5004/datasets/AIBS_import/3_prealigned"
# src_dir = "/usr/people/tmacrina/seungmount/research/Julimaps/datasets/AIBS_aligned"
# dst_dir = "/usr/people/tmacrina/seungmount/research/Julimaps/datasets/AIBS_aligned/3_prealigned"
# src_dir = "/media/tmacrina/4BED39E032CF5004/datasets/AIBS_import/0_overview"
# dst_dir = "/media/tmacrina/4BED39E032CF5004/datasets/stage_stitch/3_prealigned"
files = os.listdir(src_dir)
for file in files:
if file.endswith(".tif"):
print "Importing " + file
src_fn = os.path.join(src_dir, file)
dst_fn = os.path.join(dst_dir, "1," + str(file[2:6]) + "_montaged.h5")
# dst_fn = os.path.join(dst_dir, "1," + str(file[1:5]) + "_prealigned.h5")
if os.path.isfile(src_fn) and not os.path.isfile(dst_fn):
# print(src_fn, dst_fn)
arr = open(src_fn)
write_to_h5(dst_fn, arr)
if __name__ == '__main__':
main(sys.argv[1], sys.argv[2])
|
import glob
import sys
import time
import json
import click
import jellyfish
import numpy as np
from sklearn.metrics import recall_score, precision_score
from difflib import SequenceMatcher
from simindex import DySimII, DyLSH, DyKMeans, RecordTimer, read_csv
from simindex import MultiSimAwareAttributeIndex, WeakLabels, DisjunctiveBlockingScheme
from simindex import draw_precision_recall_curve, \
draw_record_time_curve, \
draw_frequency_distribution, \
draw_bar_chart, \
show
from simindex.similarity import sim_damerau
def _compare(a, b):
return sim_damerau(a, b)
# return SequenceMatcher(None, a, b).ratio()
def _compare_jaro(a, b):
return jellyfish.jaro_distance(a, b)
def _encode_soundex(a):
return jellyfish.soundex(a)
def _encode_metaphone(a):
return jellyfish.metaphone(a)
def _encode_first3(a):
return a.strip()[:3]
@click.command(context_settings=dict(help_option_names=[u'-h', u'--help']))
@click.argument('index_file', type=click.Path(exists=True))
@click.argument('query_file', type=click.Path(exists=True))
@click.option(
u'-i', u'--index-attributes', multiple=True,
help=u'Attribute to extract from index file.\
Use multiple times if needed!'
)
@click.option(
u'-q', u'--query-attributes', multiple=True,
help=u'List of attributes to extract from query file.\
Use multiple times if needed!'
)
@click.option(
u'-s', u'--gold-standard', type=click.Path(exists=True),
help=u'CSV with gold standard data'
)
@click.option(
u'-g', u'--gold-attributes', multiple=True,
help=u'List of attributes to extract from gold standard.\
Use multiple times if needed!'
)
@click.option(
u'-e', u'--encoding_list', multiple=True,
help=u'List of encodings to apply in order to attributes\
Use multiple times if needed!'
)
@click.option(
u'-c', u'--similarity_list', multiple=True,
help=u'List of similarities to apply in order to attributes\
Use multiple times if needed!'
)
@click.option(
u'-t', u'--run_type', help=u'What are you benchmarking?\
evaluation - calculate all metrics\
index - measure indexing time\
plot - draw results'
)
@click.option(
u'-o', u'--output', help=u'File name to print the result to or \
the read them from.'
)
@click.option(
u'-r', u'--run_name', help=u'Common prefix of output file from one\
run to draw measures collectively.'
)
@click.option(
u'-m', u'--index_method', help=u'Which method to use for indexing?\
DySimII\
DyLSH'
)
@click.option( u'-fe', u'--file_encoding', default="utf-8")
def main(index_file, index_attributes,
query_file, query_attributes,
gold_standard, gold_attributes,
encoding_list, similarity_list,
run_type, output, run_name, index_method,
file_encoding):
"""Run a basic matching task on input file."""
if (len(index_attributes) != len(query_attributes)):
print("Query attribute count must equal index attribute count!")
sys.exit(0)
# Parse encoding functions
encoding_fns = []
for encoding in encoding_list:
if encoding == "soundex":
encoding_fns.append(_encode_soundex)
elif encoding == "metaphone":
encoding_fns.append(_encode_metaphone)
elif encoding == "first3":
encoding_fns.append(_encode_first3)
# Parse similarity functions
similarity_fns = []
for similarity in similarity_list:
if similarity == "default":
similarity_fns.append(_compare)
elif similarity == "jaro":
similarity_fns.append(_compare_jaro)
if run_type == "evaluation":
measurements = {}
# Prepare record timers
insert_timer = RecordTimer()
query_timer = RecordTimer()
indexer = None
if index_method == "DySimII":
indexer = DySimII(len(index_attributes) - 1, top_n=1,
simmetric_fn=similarity_fns,
encode_fn=encoding_fns,
gold_standard=gold_standard,
gold_attributes=gold_attributes,
insert_timer=insert_timer, query_timer=query_timer)
elif index_method == "DyLSH":
indexer = DyLSH(top_n=1, lsh_threshold=0.25, lsh_num_perm=60,
similarity_fn=similarity_fns,
encode_fn=encoding_fns,
gold_standard=gold_standard,
gold_attributes=gold_attributes,
insert_timer=insert_timer, query_timer=query_timer)
elif index_method == "DyKMeans":
indexer = DyKMeans(top_n=1, k=50,
similarity_fn=similarity_fns,
encode_fn=encoding_fns,
gold_standard=gold_standard,
gold_attributes=gold_attributes,
insert_timer=insert_timer,
query_timer=query_timer)
# Build index
print("Building index with", indexer)
start = time.time()
indexer.fit_csv(index_file, index_attributes)
end = time.time()
measurements["build_time"] = end - start
print("Index build time: %f" % measurements["build_time"])
print("Index build time (sum): %f" % (sum(insert_timer.times) + sum(insert_timer.common_time)))
insert_timer.apply_common()
measurements["insert_times"] = insert_timer.times
if index_method == "DySimII":
measurements["block_frequency"] = {}
for index, block_freq in enumerate(indexer.frequency_distribution()):
measurements["block_frequency"][index_attributes[index + 1]] = block_freq
elif index_method == "DyLSH" or index_method == "DyKMeans":
measurements["block_frequency"] = indexer.frequency_distribution()
# Run Queries
start = time.time()
result, \
measurements["y_true1"], \
measurements["y_scores"], \
measurements["y_true2"], \
measurements["y_pred"] \
= indexer.query_from_csv(query_file, query_attributes)
end = time.time()
measurements["query_time"] = end - start
print("Index query time: %f" % measurements["query_time"])
print("Index query time (sum): %f" % (sum(query_timer.times) + sum(query_timer.common_time)))
query_timer.apply_common()
measurements["query_times"] = query_timer.times
mean = np.mean(query_timer.times)
print("Query mean:", mean)
print("Queries (s):", 1 / mean)
print("Total candidate pairs:", indexer.candidate_count)
if index_method == "DyLSH":
print ("EQ Count:", indexer.saai.eq_count)
print ("SI Count:", indexer.saai.si_count)
print ("SIM Count:", indexer.saai.sim_count)
# imba = {"all": query_timer.times,
# "minhash": [x[0] for x in query_timer.marker],
# "lsh": [x[1] for x in query_timer.marker],
# "simaware": [x[2] for x in query_timer.marker]}
# draw_record_time_curve(imba, "blub", "haha")
# show()
# Calculate Precision/Recall
measurements["query_records"] = len(result)
print("Query records:", measurements["query_records"])
# @WARNING: Takes a lot of time to compute
# measurements["recall_blocking"] = indexer.recall()
# print("Recall blocking:", measurements["recall_blocking"])
measurements["precision"] = precision_score(measurements["y_true2"],
measurements["y_pred"])
print("P1:", measurements["precision"])
measurements["recall"] = recall_score(measurements["y_true2"],
measurements["y_pred"])
print("R1:", measurements["recall"])
fp = open(output, mode='w')
json.dump(measurements, fp, sort_keys=True, indent=4)
elif run_type == "selfconfig":
measurements = {}
# Prepare record timers
insert_timer = RecordTimer()
query_timer = RecordTimer()
labels = WeakLabels(max_positive_pairs=4, max_negative_pairs=4)
print("Predict weak labels")
start = time.time()
labels.fit(read_csv(index_file))
end = time.time()
measurements["label_time"] = end - start
print("Prediction time:", measurements["label_time"])
# dnfblock = DisjunctiveBlockingScheme(blocking_keys, labels)
# dnf = dnfblock.transform()
# MultiSimAwareAttributeIndex(dnf, __compare)
pass
elif run_type == "index":
fp = open(output)
measurements = json.load(fp)
fp.close()
indexer = None
if index_method == "DySimII":
indexer = DySimII(len(index_attributes) - 1,
simmetric_fn=similarity_fns,
encode_fn=encoding_fns)
elif index_method == "DyLSH":
indexer = DyLSH(top_n=1, lsh_threshold=0.25, lsh_num_perm=60,
similarity_fn=similarity_fns,
encode_fn=encoding_fns)
elif index_method == "DyKMeans":
indexer = DyKMeans(top_n=1,
similarity_fn=similarity_fns,
encode_fn=encoding_fns)
start = time.time()
indexer.fit_csv(index_file, index_attributes)
end = time.time()
measurements["build_time"] = end - start
fp = open(output, mode='w')
json.dump(measurements, fp, sort_keys=True, indent=4)
elif run_type == "plot":
memory_usage = {}
index_build_time = {}
insert_times = {}
query_times = {}
for resultfile in glob.glob("./%s*" % run_name):
fp = open(resultfile)
measurements = json.load(fp)
fp.close()
indexer_dataset = resultfile[resultfile.index('_') + 1:]
indexer = indexer_dataset[:indexer_dataset.index('_')]
dataset = indexer_dataset[indexer_dataset.index('_') + 1:]
if dataset not in insert_times:
insert_times[dataset] = {}
query_times[dataset] = {}
insert_times[dataset][indexer] = measurements["insert_times"]
query_times[dataset][indexer] = measurements["query_times"]
draw_frequency_distribution(measurements["block_frequency"],
indexer_dataset,
"Block")
draw_precision_recall_curve(measurements["y_true1"],
measurements["y_scores"],
indexer_dataset)
# Sort data by indexer and then by dataset
if indexer not in memory_usage:
memory_usage[indexer] = {}
index_build_time[indexer] = {}
memory_usage[indexer][dataset] = measurements["memory_usage"] / 1024
index_build_time[indexer][dataset] = measurements["build_time"]
for dataset in insert_times.keys():
draw_record_time_curve(insert_times[dataset], dataset, "insertion")
for dataset in query_times.keys():
draw_record_time_curve(query_times[dataset], dataset, "query")
draw_bar_chart(memory_usage, "Memory usage", "MiB")
draw_bar_chart(index_build_time, "Index build time", "Seconds (s)")
# Show plots
show()
sys.exit(0)
if __name__ == "__main__": # pragma: no cover
main(prog_name="benchmark")
|
from PyQt4 import QtGui
from PyQt4 import QtCore
import sys
sys.path.append('..')
from aei import board
ANIMATE_ONE = 0.2
DIRECTIONS = {'n' : -8, 'w' : -1, 'e' : 1, 's': 8}
MAX_MOVE_INTERVAL = 1500
STEP_INTERVAL = 300
ERROR = -1
BSIDE = 8
BSIZE = 64
COL_EMPTY = 2
COLORS = ['Gold', 'Silver', '']
PIECE_EMPTY_STR = 'Empty'
PIECES = {'r': 'Rabbit', 'c': 'Cat', 'd': 'Dog', 'h': 'Horse', 'm': 'Camel', 'e': 'Elephant', ' ' : PIECE_EMPTY_STR}
PIECES_NUM = ['r', 'c', 'd', 'h', 'm', 'e', ' ']
EDGE = 2.5
MODE_PLAY, MODE_REPLAY = range(2)
STEPSTR_LEN = 4
def stepstr2from(stepstr):
return BSIZE - 1 - board.alg_to_index(stepstr[1:STEPSTR_LEN - 1])
def stepstr2to(stepstr):
dir = stepstr[STEPSTR_LEN - 1]
return stepstr2from(stepstr) + DIRECTIONS[dir]
def scale_pixmap(pixmap, size, ar=None):
return pixmap.scaled(size.width(), size.height(), ar and ar or QtCore.Qt.KeepAspectRatio)
class BoardWidget(QtGui.QWidget):
def __init__(self, widget):
self.pos = None
self.ps_stack = None
self.mode = None
self.mover = QtCore.QTimeLine(MAX_MOVE_INTERVAL)
self.mover.setCurveShape(self.mover.LinearCurve)
self.connect(self.mover, QtCore.SIGNAL("frameChanged(int)"), self.animate_move)
widget = super(BoardWidget, self).__init__(widget)
self.square_width = 0
self.square_height = 0
self.repaint_index = None
self.setMouseTracking(True)
#actually marked squares
self.marked = []
self.last_upon = None
return widget
def compute_rec(self, index):
rec = self.geometry()
left = rec.x() - EDGE + (index % BSIDE) * self.square_width
top = rec.y() - EDGE + (index / BSIDE) * self.square_height
return QtCore.QRect(left, top, self.square_width, self.square_height)
def point2index(self, point):
row = int(point.y() / self.square_height)
col = int(point.x() / self.square_width)
return BSIDE * row + col
def resizeEvent(self, e):
rec = self.geometry()
self.board_pixmap = scale_pixmap(QtGui.QPixmap("img/BoardStoneBigCut.jpg"), rec)
rec.setHeight(self.board_pixmap.height())
rec.setWidth(self.board_pixmap.width())
self.square_width = (rec.width() - EDGE)/ float(BSIDE)
self.square_height = (rec.height() - EDGE)/ float(BSIDE)
self.repaint()
def xmousePressEvent(self, e):
index = self.point2index(e.pos())
if not self.square_empty(index):
return
steps = filter(lambda x: stepstr2to(x) == index, self.marked)
if steps == []:
return
#there might be more steps with same prefix e.g. Eg5w, Eg5w hg4n, etc.
step = steps[0][0:STEPSTR_LEN]
steps = map(lambda x: x.partition(step)[2].strip(), steps)
new_pos = self.pos.do_step(board.parse_move(step))
print new_pos.to_short_str()
new_steps = [ s for s in filter(lambda x: x != '', steps)]
if '' in steps:
new_steps += [ board.steps_to_str(step) for step, _ in new_pos.get_steps()]
self.update_pos_inner(new_pos, new_steps)
def xmouseMoveEvent(self, e):
index = self.point2index(e.pos())
#check whether cursor is upon new square
if index != self.last_upon:
self.last_upon = index
if self.square_empty(index):
if index not in map(stepstr2to, self.marked):
self.marked = []
self.repaint()
#square with a piece -> update marked
else:
state = self.ps_stack[-1]
self.marked = [stepstr for stepstr in state[1]
if stepstr2from(stepstr) == index and self.square_empty(stepstr2to(stepstr))]
self.repaint()
def paintEvent(self, e):
painter = QtGui.QPainter(self)
painter.drawPixmap(0, 0, self.board_pixmap)
if self.pos:
if self.repaint_index:
c = self.pos.to_short_str()[1:-1][self.repaint_index]
player = (c == ' ' and COL_EMPTY or (c.islower() and 1 or 0))
self.draw_square(painter, player, c.lower(), self.repaint_index)
self.repaint_index = None
else: #repaint all
for index, c in enumerate(self.pos.to_short_str()[1:-1]):
player = (c == ' ' and COL_EMPTY or (c.islower() and 1 or 0))
self.draw_square(painter, player, c.lower(), index)
if self.mode == MODE_PLAY:
#draw marked squares
for m in map(stepstr2to, self.marked):
self.draw_mark(painter, m)
def start_move_animation(self, steps):
self.steps = steps
self.mover.setDuration(min(len(steps) * STEP_INTERVAL, MAX_MOVE_INTERVAL))
self.mover.setCurrentTime(0)
self.mover.setFrameRange(0, len(steps))
self.mover.start()
def animate_move(self, frame):
if frame == 0:
return
(_, from_in), (_, to_in), step_piece, step_color = self.steps[frame - 1]
to_in = BSIZE - to_in - 1
from_in = BSIZE - from_in - 1
self.pos = self.pos.do_move([self.steps[frame -1]])
#erase previous
if from_in != ERROR: #not an init => clear previous position
index = from_in
self.repaint_index = index
self.repaint(self.compute_rec(index))
if to_in == ERROR: #trapped
index = to_in
else: #ok
index = to_in
self.repaint_index = index
self.repaint(self.compute_rec(index))
def update_pos(self, pos):
self.mover.stop()
steps = [ board.steps_to_str(step) for step, _ in pos.get_steps()]
self.update_pos_inner(pos, steps)
def update_pos_inner(self, pos, steps):
self.pos = pos
self.ps_stack = [(pos, steps)]
self.last_upon = None
self.marked = []
self.repaint()
def square_empty(self, index):
assert index >= 0 and index < BSIZE, "wrong square index"
return self.pos.to_short_str()[1:-1][index] == ' '
def draw_pixmap(self, painter, img, index):
pixmap = scale_pixmap(QtGui.QPixmap(img), self.compute_rec(index))
painter.drawPixmap(self.compute_rec(index).x(), self.compute_rec(index).y(), pixmap)
def draw_square(self, painter, player, piece, index):
s = "img/%s%s.gif" % (COLORS[player], PIECES[piece])
self.draw_pixmap(painter, s, index)
def draw_mark(self, painter, index):
s = "img/mark.png"
self.draw_pixmap(painter, s, index)
|
"""
This module deals with everything related to the overlay text generated,
as well as formating how to display stats
"""
from game_objects.item import ItemInfo
class Overlay(object):
"""The main class to handle output to overlay text files"""
def __init__(self, prefix, tracker_state):
self.state = tracker_state
self.prefix = prefix
@staticmethod
def format_value(value):
"""Format a float value for displaying"""
# NOTE this is not only used in this class
# Round to 2 decimal places then ignore trailing zeros and trailing periods
# Doing just 'rstrip("0.")' breaks on "0.00"
display = format(value, ".2f").rstrip("0").rstrip(".")
# For example, set "0.6" to ".6"
if abs(value) < 1 and value != 0:
display = display.lstrip("0")
if value > -0.00001:
display = "+" + display
return display
@staticmethod
def format_transform(transform_set):
"""Format a transform_set for displaying"""
# NOTE this is not only used in this class
if len(transform_set) >= 3:
return "yes"
else:
return str(len(transform_set))
def update_stats(self, stat_list=None, transform_list=None):
"""
Update file content for a subset (or all) the player's stats.
stat_list provide the subset of stats to update, if None it will update everything
"""
if stat_list is None:
stat_list = ItemInfo.stat_list
for stat in stat_list:
display = Overlay.format_value(self.state.player_stats[stat])
with open(self.prefix + "overlay text/" + stat + ".txt", "w+") as sfile:
sfile.write(display)
if transform_list is None:
transform_list = ItemInfo.transform_list
for transform in transform_list:
display = Overlay.format_transform(self.state.player_transforms[transform])
with open(self.prefix + "overlay text/" + transform + ".txt", "w+") as sfile:
sfile.write(display)
def update_last_item_description(self):
"""Update the overlay file for item pickup description"""
item = self.state.last_item
desc = item.info.name
desc += ": " + item.generate_item_description()
with open(self.prefix + "overlay text/itemInfo.txt", "w+") as sfile:
sfile.write(desc)
def update_seed(self):
"""Update the overlay file the seed"""
with open(self.prefix + "overlay text/seed.txt", "w+") as sfile:
sfile.write(self.state.seed)
|
__author__ = 'July'
import threading
import time
import logging
import random
import Queue
'''
from redis import Redis
from rq import Queue
'''
from functools import partial
from multiprocessing.pool import Pool
# Below example implement P-C using Queue.Queue - a sync queue class
# Queue encapsulates the behaviour of Condition, wait(), notify(), acquire() etc.
# https://docs.python.org/2/library/queue.html
# Java - blocking queue : http://tutorials.jenkov.com/java-concurrency/blocking-queues.html
"""
http://www.bogotobogo.com/python/Multithread/python_multithreading_Synchronization_Producer_Consumer_using_Queue.php
The producer's job is to generate a piece of data, put it into the buffer and start again.
At the same time, the consumer is consuming the data (i.e., removing it from the buffer) one piece at a time
The problem describes two processes, the producer and the consumer, who share a common,
fixed-size buffer used as a queue.
In place of list, we are using a Queue instance(hereafter queue).
queue has a Condition and that condition has its lock. You don't need to bother about Condition and Lock if you use Queue.
Producer uses put available on queue to insert data in the queue.
put() has the logic to acquire the lock before inserting data in queue.
Also put() checks whether the queue is full. If yes, then it calls wait() internally and so producer starts waiting.
Consumer uses get.
get() acquires the lock before removing data from queue.
get() checks if the queue is empty. If yes, it puts consumer in waiting state.
get() and put() has proper logic for notify() too.
"""
# Set up some global variables
logging.basicConfig(level=logging.DEBUG, format='( %(threadName) - 9s %(message)s',)
BUF_SIZE = 3
q = Queue.Queue(BUF_SIZE)
num_fetch_threads = 2
class ProducerThread(threading.Thread):
def __init__(self, group = None, target = None, name = None, args = (), kwargs = None, verbose = None):
super(ProducerThread, self).__init__()
self.target = target
self.name = name
self.setDaemon(True)
def run(self):
cnt = 0
while cnt < 10:
if not q.full():
item = random.randint(1, 9)
q. put(item)
cnt += 1
logging.debug('Putting ' + str(item) + ': ' + str(q.qsize()) + ' in queue )')
time.sleep(random.random())
return
class ConsumerThread(threading.Thread):
"""This is the Worker thread function.
It putting items in the queue one after
another. These daemon threads go into an
infinite loop, and only exit when
the main thread ends.
"""
def __init__(self, group = None, target = None, name = None, args = (), kwargs = None, verbose = None):
super(ConsumerThread, self).__init__()
self.target = target
self.name = name
self.setDaemon(True)
def run(self):
cnt = 0
while True:
if not q.empty():
item = q.get()
logging.debug('Getting ' + str(item) + ': ' + str(q.qsize()) + ' in queue )')
cnt += 1
time.sleep(random.random())
return
if __name__ == '__main__':
producer = ProducerThread(name = 'Producer')
producer.start()
time.sleep(2)
for i in xrange(num_fetch_threads):
name = 'consumer' + str(i)
consumer = ConsumerThread(name = name)
consumer.start()
time.sleep(2)
logging.debug('*** Main thread waiting')
logging.debug(producer.isAlive())
logging.debug('*** Done')
|
import numpy as np
import chromathicity.defaults
from chromathicity.illuminant import D
from chromathicity.interfaces import RgbSpecification, Compander
from chromathicity.observer import Standard
from chromathicity.util import SetGet
class Custom(RgbSpecification, SetGet):
def __init__(self, **kwargs):
super().__init__()
self._name = ""
self._illuminant = chromathicity.defaults.get_default_illuminant()
self._observer = chromathicity.defaults.get_default_observer()
self._xyy = np.array([[0.6, 0.3, .200],
[0.3, 0.6, .800],
[0.2, 0.1, .100]])
self.set(**kwargs)
def __repr__(self):
args = ['name', 'illuminant', 'observer', 'xyy']
kwargs_repr = ', '.join(f'{key}={getattr(self, key)!r}' for key in args)
return f'Custom({kwargs_repr!s})'
@property
def name(self):
return self._name
@name.setter
def name(self, n):
self._name = n
@property
def illuminant(self):
return self._illuminant
@illuminant.setter
def illuminant(self, ill):
self._illuminant = ill
@property
def observer(self):
return self._observer
@observer.setter
def observer(self, obs):
self._observer = obs
@property
def xyy(self):
return self._xyy
@xyy.setter
def xyy(self, x):
self._xyy = x
class Srgb(RgbSpecification):
def __init__(self):
super().__init__()
self.compander = SrgbCompander()
def __repr__(self):
return 'Srgb()'
@property
def name(self):
return 'sRGB'
@property
def illuminant(self):
return D('D_65')
@property
def observer(self):
return Standard(2)
@property
def xyy(self):
return np.array([[0.64, 0.33, .212656],
[0.30, 0.60, .715158],
[0.15, 0.06, .072186]])
class SrgbCompander(Compander):
_EPS = 0.0031308
_DELTA = 12.92
_ALPHA = 1.055
_GAMMA = 2.4
_BETA = 0.055
def __repr__(self):
return 'SrgbCompander()'
def compand(self, linear_rgb: np.ndarray) -> np.ndarray:
is_small = linear_rgb <= self._EPS
is_big = np.logical_not(is_small)
companded_rgb = np.zeros(linear_rgb.shape)
companded_rgb[is_small] = self._DELTA * linear_rgb[is_small]
a = self._ALPHA
g = self._GAMMA
b = self._BETA
companded_rgb[is_big] = a*linear_rgb[is_big] ** (1.0/g) - b
return companded_rgb
def inverse_compand(self, companded_rgb: np.ndarray) -> np.ndarray:
is_small = companded_rgb <= self._DELTA*self._EPS
is_big = np.logical_not(is_small)
linear_rgb = np.zeros(companded_rgb.shape)
linear_rgb[is_small] = companded_rgb[is_small] / self._DELTA
a = self._ALPHA
g = self._GAMMA
b = self._BETA
linear_rgb[is_big] = ((companded_rgb[is_big] + b) / a) ** g
return linear_rgb
class GammaCompander(Compander):
def __init__(self, gamma=1):
self.gamma = gamma
def __repr__(self):
return f'GammaCompander({self.gamma!r})'
def compand(self, linear_rgb: np.ndarray) -> np.ndarray:
return linear_rgb ** (1.0 / self.gamma)
def inverse_compand(self, companded_rgb: np.ndarray) -> np.ndarray:
return companded_rgb ** self.gamma
|
import json
lexicon = {
'pron_me': ['i', "i'd", "i'll", "i'm", "i've", 'id', 'im', 'ive',
'me', 'mine', 'my', 'myself'],
'pron_we': ["let's", 'lets', 'our', 'ours', 'ourselves', 'us',
'we', "we'd", "we'll", "we're", "we've", 'weve'],
'pron_you': ["y'all", 'yall', 'you', "you'd", "you'll", "you're",
"you've", 'youd', 'youll', 'your', 'youre', 'yours',
'youve'],
'pron_3rd': ['he', "he'd", "he's", 'hed', 'her', 'hers', 'herself',
'hes', 'him', 'himself', 'his', 'she', "she'd",
"she'll", "she's", 'shes'],
'pron_3rd_plural': ['their', 'them', 'themselves',
'they', "they'd", "they'll", "they've", 'theyd', 'theyll',
'theyve', "they're", "theyre"]
}
lexicon['positive'] = []
with open('liu-positive-words.txt') as f:
for line in f:
lexicon['positive'].append(line.strip())
lexicon['negative'] = []
with open('liu-negative-words.txt', encoding='ISO-8859-1') as f:
for line in f:
lexicon['negative'].append(line.strip())
with open('lexicons', 'w') as w:
json.dump(lexicon, w)
|
"""
Admin views for loading and editing puzzles.
Puzzles and blank grids are viewed as whole units using inline
elements. Some extra fields are added to upload XML and ipuz files
instead of relying on manual data entry.
"""
import json
from xml.etree import ElementTree
from django.contrib import admin
from django.db.models import CharField
from django.forms import TextInput, FileField, ModelForm
from puzzle.models import Puzzle, Entry, Blank, Block
XMLNS = '{http://crossword.info/xml/rectangular-puzzle}'
def import_from_xml(xml, puzzle):
"""Load a puzzle from Crossword Compiler XML format into the database."""
# pylint: disable=no-member
# false +ve on xml.etree.ElementTree.Element (v1.64)
crossword = ElementTree.parse(xml).find('*/%scrossword' % XMLNS)
for word in crossword.iter('%sword' % XMLNS):
xraw = word.attrib['x'].split('-')
yraw = word.attrib['y'].split('-')
xstart = int(xraw[0])
ystart = int(yraw[0])
down = len(yraw) > 1
clue = crossword.find('*/%sclue[@word="%s"]' % (XMLNS, word.attrib['id'])).text
if 'solution' in word.attrib:
answer = word.attrib['solution']
else:
answer = ''
if down:
for y in range(ystart, int(yraw[1]) + 1):
answer += crossword.find('*/%scell[@x="%d"][@y="%d"]' %
(XMLNS, xstart, y)).attrib['solution'].lower()
else:
for x in range(xstart, int(xraw[1]) + 1):
answer += crossword.find('*/%scell[@x="%d"][@y="%d"]' %
(XMLNS, x, ystart)).attrib['solution'].lower()
# XML is 1-based, model is 0-based
xstart -= 1
ystart -= 1
entry = Entry(puzzle=puzzle, clue=clue, answer=answer, x=xstart, y=ystart, down=down)
entry.save()
def import_blank_from_ipuz(ipuz, blank):
"""Load a blank grid from an ipuz file into the database."""
data = json.loads(ipuz.read().decode('latin_1'))
for y, row in enumerate(data['puzzle']):
for x, cell in enumerate(row):
if cell == "#":
block = Block(blank=blank, x=x, y=y)
block.save()
class PuzzleImportForm(ModelForm):
"""Add an XML import field."""
file_import = FileField(label='Import from XML', required=False)
class Meta:
model = Puzzle
fields = ['number', 'user', 'pub_date', 'comments']
class EntryInline(admin.StackedInline):
"""Increase the length of the text field for puzzle clues."""
model = Entry
formfield_overrides = {CharField: {'widget': TextInput(attrs={'size':'100'})}}
class PuzzleAdmin(admin.ModelAdmin):
"""Show entries inline and allow import from XML"""
form = PuzzleImportForm
inlines = [EntryInline]
def save_model(self, request, obj, form, change):
super(PuzzleAdmin, self).save_model(request, obj, form, change)
xml_file = form.cleaned_data.get('file_import', None)
if xml_file:
import_from_xml(xml_file, obj)
class BlankImportForm(ModelForm):
"""Add an ipuz import field."""
file_import = FileField(label='Import from ipuz', required=False)
class Meta:
model = Blank
fields = ['display_order']
class BlockInline(admin.TabularInline):
"""Show blocks in a table."""
model = Block
class BlankAdmin(admin.ModelAdmin):
"""Show blocks inline and allow import from ipuz."""
form = BlankImportForm
inlines = [BlockInline]
save_as = True
def save_model(self, request, obj, form, change):
super(BlankAdmin, self).save_model(request, obj, form, change)
ipuz_file = form.cleaned_data.get('file_import', None)
if ipuz_file:
import_blank_from_ipuz(ipuz_file, obj)
admin.site.site_header = "Three Pins Administration"
admin.site.site_title = "Three Pins"
admin.site.register(Puzzle, PuzzleAdmin)
admin.site.register(Blank, BlankAdmin)
|
import numpy as np
import pytest
from hypothesis.control import assume
from hypothesis.core import given
from scipy.spatial.qhull import QhullError, Voronoi
from crowddynamics.core.quantities import density_voronoi_1
from crowddynamics.testing import reals
def all_unique(data: np.ndarray) -> bool:
"""Test that all data rows have unique data"""
ncols = data.shape[1]
dtype = data.dtype.descr * ncols
struct = data.view(dtype)
return len(np.unique(struct)) == len(data)
def does_not_raise_Qhull_error(points):
"""Test that Voronoi tesselation does raise errors"""
try:
vor = Voronoi(points)
return True
except QhullError:
return False
@pytest.mark.skip('Fixme')
# @given(points=reals(1, 10, shape=(3, 2)))
@given(points=reals(1, 10, shape=(10, 2)))
# @given(points=reals(1, 10, shape=(100, 2)))
def test_density_voronoi_1(points):
assume(does_not_raise_Qhull_error(points))
assume(all_unique(points))
cell_size = 0.1
density = density_voronoi_1(points, cell_size=cell_size)
assert True
|
# -*- coding: utf-8 -*-
from openprocurement.api.utils import raise_operation_error, error_handler
from openprocurement.tender.belowthreshold.views.award_document import TenderAwardDocumentResource
from openprocurement.tender.core.utils import optendersresource
@optendersresource(name='aboveThresholdUA:Tender Award Documents',
collection_path='/tenders/{tender_id}/awards/{award_id}/documents',
path='/tenders/{tender_id}/awards/{award_id}/documents/{document_id}',
procurementMethodType='aboveThresholdUA',
description="Tender award documents")
class TenderUaAwardDocumentResource(TenderAwardDocumentResource):
def validate_award_document(self, operation):
""" TODO move validators
This class is inherited from below package, but validate_award_document function has different validators.
For now, we have no way to use different validators on methods according to procedure type.
"""
if self.request.validated['tender_status'] != 'active.qualification':
raise_operation_error(self.request, 'Can\'t {} document in current ({}) tender status'.format(operation, self.request.validated['tender_status']))
if any([i.status != 'active' for i in self.request.validated['tender'].lots if i.id == self.request.validated['award'].lotID]):
raise_operation_error(self.request, 'Can {} document only in active lot status'.format(operation))
if any([any([c.status == 'accepted' for c in i.complaints]) for i in self.request.validated['tender'].awards if i.lotID == self.request.validated['award'].lotID]):
raise_operation_error(self.request, 'Can\'t {} document with accepted complaint')
if operation == 'update' and self.request.authenticated_role != (self.context.author or 'tender_owner'):
self.request.errors.add('url', 'role', 'Can update document only author')
self.request.errors.status = 403
raise error_handler(self.request.errors)
return True
|
# -*- coding: utf-8 -*-
# Generated by Django 1.11 on 2017-04-16 17:36
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='SensorRecord',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('device_id', models.IntegerField()),
('fw', models.IntegerField()),
('evt', models.IntegerField()),
('coil_revesed', models.CharField(max_length=3)),
('power_active', models.FloatField()),
('power_reactive', models.FloatField()),
('power_appearent', models.FloatField()),
('current', models.FloatField()),
('voltage', models.FloatField()),
('phase', models.FloatField()),
('peaks_1', models.FloatField()),
('peaks_2', models.FloatField()),
('peaks_3', models.FloatField()),
('peaks_4', models.FloatField()),
('peaks_5', models.FloatField()),
('peaks_6', models.FloatField()),
('peaks_7', models.FloatField()),
('peaks_8', models.FloatField()),
('peaks_9', models.FloatField()),
('peaks_10', models.FloatField()),
('fft_re_1', models.FloatField()),
('fft_re_2', models.FloatField()),
('fft_re_3', models.FloatField()),
('fft_re_4', models.FloatField()),
('fft_re_5', models.FloatField()),
('fft_re_6', models.FloatField()),
('fft_re_7', models.FloatField()),
('fft_re_8', models.FloatField()),
('fft_re_9', models.FloatField()),
('fft_img_1', models.FloatField()),
('fft_img_2', models.FloatField()),
('fft_img_3', models.FloatField()),
('fft_img_4', models.FloatField()),
('fft_img_5', models.FloatField()),
('fft_img_6', models.FloatField()),
('fft_img_7', models.FloatField()),
('fft_img_8', models.FloatField()),
('fft_img_9', models.FloatField()),
('time', models.DateTimeField()),
('hz', models.FloatField()),
('wifi_strength', models.FloatField()),
('dummy', models.FloatField()),
],
),
]
|
# -*- coding: utf-8 -*-
#
# Copyright (c) 2016-2017 Ircam
# Copyright (c) 2016-2017 Guillaume Pellerin
# Copyright (c) 2016-2017 Emilie Zawadzki
# This file is part of mezzanine-organization.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# -*- encoding: utf-8 -*-
# This file is distributed under the same license as the Django package.
#
from __future__ import unicode_literals
# The *_FORMAT strings use the Django date format syntax,
# see http://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
DATE_FORMAT = 'j F Y'
DATE_EVENT_FORMAT = 'D j F'
DATE_EVENT_FORMAT_Y = 'D j F Y'
WEEK_DAY_FORMAT = 'D j'
WEEK_DAY_FORMAT_Y = 'D j Y'
TIME_FORMAT = 'H\hi'
DATETIME_FORMAT = 'j F Y H:i'
YEAR_MONTH_FORMAT = 'F Y'
MONTH_DAY_FORMAT = 'j F'
SHORT_DATE_FORMAT = 'j N Y'
SHORT_DATETIME_FORMAT = 'j N Y H:i'
FIRST_DAY_OF_WEEK = 1 # Monday
# The *_INPUT_FORMATS strings use the Python strftime format syntax,
# see http://docs.python.org/library/datetime.html#strftime-strptime-behavior
DATE_INPUT_FORMATS = [
'%d/%m/%Y', '%d/%m/%y', # '25/10/2006', '25/10/06'
'%d.%m.%Y', '%d.%m.%y', # Swiss [fr_CH), '25.10.2006', '25.10.06'
# '%d %B %Y', '%d %b %Y', # '25 octobre 2006', '25 oct. 2006'
]
DATETIME_INPUT_FORMATS = [
'%d/%m/%Y %H:%M:%S', # '25/10/2006 14:30:59'
'%d/%m/%Y %H:%M:%S.%f', # '25/10/2006 14:30:59.000200'
'%d/%m/%Y %H:%M', # '25/10/2006 14:30'
'%d/%m/%Y', # '25/10/2006'
'%d.%m.%Y %H:%M:%S', # Swiss [fr_CH), '25.10.2006 14:30:59'
'%d.%m.%Y %H:%M:%S.%f', # Swiss (fr_CH), '25.10.2006 14:30:59.000200'
'%d.%m.%Y %H:%M', # Swiss (fr_CH), '25.10.2006 14:30'
'%d.%m.%Y', # Swiss (fr_CH), '25.10.2006'
]
DECIMAL_SEPARATOR = ','
THOUSAND_SEPARATOR = '\xa0' # non-breaking space
NUMBER_GROUPING = 3
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'Will Brennan'
import argparse
import logging
import cv2
import skin_detector
logger = logging.getLogger('main')
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('image_paths', type=str, nargs='+', help="paths to one or more images or image directories")
parser.add_argument('-b', '--debug', dest='debug', action='store_true', help='enable debug logging')
parser.add_argument('-q', '--quite', dest='quite', action='store_true', help='disable all logging')
parser.add_argument('-d', '--display', dest='display', action='store_true', help="display result")
parser.add_argument('-s', '--save', dest='save', action='store_true', help="save result to file")
parser.add_argument('-t', '--thresh', dest='thresh', default=0.5, type=float, help='threshold for skin mask')
args = parser.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("main")
for image_arg in args.image_paths:
for image_path in skin_detector.find_images(image_arg):
logging.info("loading image from {0}".format(image_path))
img_col = cv2.imread(image_path, 1)
img_msk = skin_detector.process(img_col)
if args.display:
skin_detector.scripts.display('img_col', img_col)
skin_detector.scripts.display('img_msk', img_msk)
skin_detector.scripts.display('img_skn', cv2.bitwise_and(img_col, img_col, mask=img_msk))
cv2.waitKey(0)
|
# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Changing field 'Game.host'
db.alter_column(u'game_game', 'host_id', self.gf('django.db.models.fields.related.ForeignKey')(null=True, to=orm['game.MemoUser']))
def backwards(self, orm):
# Changing field 'Game.host'
db.alter_column(u'game_game', 'host_id', self.gf('django.db.models.fields.related.ForeignKey')(default=None, to=orm['game.MemoUser']))
models = {
u'auth.group': {
'Meta': {'object_name': 'Group'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
u'auth.permission': {
'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
u'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
u'game.configuration': {
'Meta': {'object_name': 'Configuration'},
'charValue': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True'}),
'game': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['game.Game']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intValue': ('django.db.models.fields.IntegerField', [], {'null': 'True'}),
'type': ('django.db.models.fields.CharField', [], {'max_length': '3'})
},
u'game.game': {
'Meta': {'object_name': 'Game'},
'comment': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True'}),
'host': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'hosted_games_set'", 'null': 'True', 'to': u"orm['game.MemoUser']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'players': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['game.MemoUser']", 'symmetrical': 'False'}),
'state': ('django.db.models.fields.CharField', [], {'default': "'WA'", 'max_length': '2'})
},
u'game.memouser': {
'Meta': {'object_name': 'MemoUser'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
u'game.statistic': {
'Meta': {'object_name': 'Statistic'},
'charValue': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True'}),
'game': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['game.Game']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intValue': ('django.db.models.fields.IntegerField', [], {'null': 'True'}),
'player': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['game.MemoUser']", 'null': 'True'}),
'type': ('django.db.models.fields.CharField', [], {'max_length': '3'})
}
}
complete_apps = ['game']
|
#!/Users/kevanahlquist/Dropbox/dev/dci_notify/env/bin/python
'''
Monitor the dci.org website for new score postings.
'''
from __future__ import print_function
#Initialize Sentry before others, requires SENTRY_DSN environment variable
from raven import Client
client = Client()
# Imports
from bs4 import BeautifulSoup
from datetime import datetime
from email.mime.text import MIMEText
from requests.exceptions import ConnectionError
from socket import error as SocketError
import json
import os
import requests
import smtplib
import time
# Config directives
MAIL_SERVER = 'smtp.mailgun.org'
MAIL_PORT = 465
MAIL_USE_TLS = False
MAIL_USE_SSL = True
MAIL_USERNAME = os.environ.get('MAIL_USERNAME', '[email protected]')
MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD', 'example_password')
MAIL_DEFAULT_SENDER = os.environ.get('MAIL_DEFAULT_SENDER', '[email protected]')
MAIL_SUPPRESS_SEND = os.environ.get('MAIL_SUPPRESS_SEND', False)
APP_SUPPRESS_POST = os.environ.get('APP_SUPPRESS_POST', False)
API_POST_URL = os.environ.get('API_POST_URL', 'http://example.com/events/') # 'http://corpscores.herokuapp.com/events/'
RECIPIENT = '[email protected]' # Emails message before sending to SMS.
# May be able to ignore basedir, make file wherever script is running
basedir = os.path.abspath(os.path.dirname(__file__))
OUTFILE = os.path.join(basedir, 'lastscrape.txt')
API_KEY = os.environ.get('API_KEY', 'API_KEY')
# JSONify dates in ISO 8601 format
dthandler = lambda obj: (
obj.isoformat()
if isinstance(obj, datetime)
else json.JSONEncoder().default(obj))
def eqIn(item, iterable):
'''Quick in operator to test for equality instead of identity'''
for thing in iterable:
if item == thing:
return True
return False
def send_email(text):
'''Send the raw event to an admin.'''
msg = MIMEText(text)
msg['Subject'] = 'New Event posted on DCI.org'
msg['From'] = MAIL_DEFAULT_SENDER
msg['To'] = RECIPIENT
if not MAIL_SUPPRESS_SEND:
s = smtplib.SMTP(MAIL_SERVER)
s.login(MAIL_USERNAME, MAIL_PASSWORD)
s.sendmail(MAIL_DEFAULT_SENDER, [RECIPIENT], msg.as_string())
def post_to_app(text):
"""Post event to app, text is a string containing a json object."""
headers = {'Content-type': 'application/json',
'Accept': 'application/json'}
r = requests.post(API_POST_URL, data=text, headers=headers)
if r.status_code != 200:
raise IOError('Unable to post event to app: %s' % text)
def process_event(event):
'''Retrieve, parse, and send the scores for the given event UUID.'''
params = {'event': event}
try:
r = requests.get('http://www.dci.org/scores/index.cfm', params=params)
except (SocketError, ConnectionError):
return
if r.status_code != 200:
return
# Get coarse info out of page
soup = BeautifulSoup(r.text)
scoresTable = (soup.find_all('table')[5].
find_all('table')[1])
infoHeader = (soup.find_all('table')[5].
find('h3'))
infoList = list(infoHeader.strings)
# Build a new event structure
thisEvent = {}
thisEvent['date'] = datetime.strptime(infoList[0], '%A, %B %d, %Y')
thisEvent['name'] = infoList[2]
loc = infoList[1].rsplit(' ', 1)
thisEvent['city'] = loc[0].rstrip(',\n\r\t ')
thisEvent['state'] = loc[1]
# Parse scores
rows = scoresTable.findChildren('tr')[2:-2]
eventResults = []
for row in rows:
columns = row.findChildren('td')
cleanColumns = [col.text.strip() for col in columns]
if len(cleanColumns) < 3:
break # Some events have Exhibition/International class labels
result = {}
result['place'] = cleanColumns[0]
result['corps'] = cleanColumns[1]
result['score'] = cleanColumns[2]
eventResults.append(result)
thisEvent['results'] = eventResults
thisEvent['api_key'] = API_KEY
event_text = json.dumps(thisEvent,
sort_keys=True,
indent=2,
default=dthandler)
#send_email(event_text)
add_processed_event(event)
if not APP_SUPPRESS_POST:
post_to_app(event_text)
def set_processed_events(events):
'''Write all processed events out to persistent storage.'''
with open(OUTFILE, 'w') as f:
f.writelines('%s\n' % event for event in events)
def get_processed_events():
'''Retrieve all processed events from persistent storage.'''
try:
with open(OUTFILE, 'r') as f:
ret = f.readlines()
ret = [item.strip() for item in ret]
except IOError:
ret = []
return ret
def add_processed_event(event):
'''Add a single new event to the processed events collection.'''
events = get_processed_events()
if event not in events:
events += event
set_processed_events(events)
def scrape_func():
'''Entry method when script is run.
Download scores page to obtain list of event UUIDs, compare to previously
processed events, process any new events.
'''
try:
# Base /scores URL redirects to the most recent score data
r = requests.get('http://www.dci.org/scores', allow_redirects=True)
except (SocketError, ConnectionError):
return
if r.status_code != 200:
return
soup = BeautifulSoup(r.text)
try:
options = soup.find('select').findChildren()
except AttributeError:
return None
current_events = [opt['value'] for opt in options]
last_processed_events = get_processed_events()
diff = [item for item in current_events if not eqIn(item,
last_processed_events)]
if diff:
for event in diff:
process_event(event)
if __name__ == '__main__':
while True:
try:
scrape_func()
except Exception as e:
print(e)
time.sleep(60)
|
# coding=utf8
#
"""
跟远程API服务器交互的通用逻辑
"""
import os
import json
import socket
import urllib
import datetime
import requests
import traceback
import config
API_HOST = "http://180.76.149.212:8083"
GRAPHQL_HOST = "%s/graphql?query=%%s" % API_HOST
def to_url_params(params):
"""
根据GET参数的请求对URL进行编码
@param params: GET参数
@type params: Dict
:return: urllib.urlencode(params)
"""
if not params:
return ""
new_params = {}
for k,v in params.items():
if isinstance(v, unicode):
new_params[k] = v.encode('utf-8')
elif isinstance(v, str):
new_params[k] = v
else:
raise
return urllib.urlencode(new_params)
def request(method, url, params=None):
"""
封装起来的请求远程服务器的操作
@param method: 请求的HTTP Method
@type method: String
@param url: 请求的PATH
@type url: String
@param params: 请求所带的参数
@type params: Dict
@param ak: 请求所带的access_Key
@type ak: String
:return: api_response
"""
start_time = str(datetime.datetime.now())
headers = {}
headers['X-Auth-Access-Key'] = config.API_ACCESS_KEY
query_dict = {"headers": headers,
"verify": False,
"timeout": 60}
data = None if not params else params
if method == 'GET' and params:
url += '?' + to_url_params(params)
data = None
else:
if data:
query_dict["data"] = data
status_code = 0
try:
resp = requests.request(method, url, **query_dict)
status_code = resp.status_code
resp = resp.json()
except:
resp = {'success':False, 'result':traceback.format_exc()}
resp['status_code'] = status_code
resp['time'] = resp.get('time', {})
resp['time']['api_start'] = start_time
resp['time']['api_end'] = str(datetime.datetime.now())
return resp
def get_crawler_seed():
"""
获取采集的种子
:return: {"data": {"tasks": cseeds[0].get("node")}}
"""
query_str = ''' query fetchCrawlerSeeds{allCrawlerSeeds(source: "pcbaby") {
edges {
node {
id,
name,
source,
url,
status
}
}
}}
'''
data = request("GET", GRAPHQL_HOST % query_str)
cseeds = data.get("data", {}).get("allCrawlerSeeds", {}).get("edges", [{}])
print cseeds
if not cseeds or cseeds[0].get("status") == "finished":
return {}
else:
return {"data": {"seeds": cseeds[0].get("node")}}
def get_crawler_task(source):
"""
从anduin的远程服务请求一个监控任务
@param source: 爬虫任务对应的来源
@type source: String
:return: {"data": {"tasks": ctasks[0].get("node")}}
"""
query_str = ''' query fetchCrawlerTasks{allCrawlerTasks(source: "%s") {
edges {
node {
id,
name,
url,
status,
category,
ttype
}
}
}}
'''
query_str = query_str % source
data = request("GET", GRAPHQL_HOST % query_str)
ctasks = data.get("data", {}).get("allCrawlerTasks", {}).get("edges", [{}])
if not ctasks or ctasks[0].get("status") == "finished":
return {}
else:
return {"data": {"tasks": ctasks[0].get("node")}}
def update_crawler_task_by_rest_api(task_result):
"""
通过post请求将接口数据更新到远程服务器
@param task_result: 爬虫任务采集的结果
@type task_result: Dict
:return: {}
"""
url = "%s/update_crawler_task/" % API_HOST
data = {"task_result": task_result}
return request("POST", url, params=data)
def register_crawler_node(task_result):
""" 将当前爬虫节点注册到服务器上 """
query_str = '''
mutation MTMutation {
cnodes(input: {nodeInfo: "%s"}) {
cnode {
id,
name,
remoteAddr,
status
}
}
}
'''
query_str = query_str % str(task_result)
url = GRAPHQL_HOST % query_str
return request("POST", url)
def update_crawler_task(task_result):
""" 将数据更新到远程服务器上 """
query_str = '''
mutation MTMutation {
ctasks(input: {taskResult: "%s"}) {
ctask {
id,
status
}
}
}
'''
query_str = query_str % str(task_result)
url = GRAPHQL_HOST % query_str
return request("POST", url)
if __name__ == "__main__":
#import json
#import base64
#task_result = {"name": "%s-%s" % (socket.gethostname(), os.getpid())}
#print register_crawler_node(base64.urlsafe_b64encode(json.dumps(task_result)))
print get_crawler_seed()
|
from django.conf import settings
from django.core.mail import send_mail
from django.core.management.base import BaseCommand
from ...models import Win, Notification
from ...notifications import generate_customer_email, generate_officer_email
class Command(BaseCommand):
def add_arguments(self, parser):
parser.add_argument("--ids", type=str)
parser.add_argument("--change_ids", type=str)
def thing(self, given_win_ids):
wins = Win.objects.filter(id__in=given_win_ids)
found_win_ids = set(str(win.id).replace('-', '') for win in wins)
missing_win_ids = set(given_win_ids) - found_win_ids
assert not missing_win_ids, "missing win ids: %s" % missing_win_ids
return wins
def make_customer_email_dict(self, win):
url = ("https://www.exportwins.service.trade.gov.uk/wins/review/" +
str(win.pk)) # should not be hardcoded
return generate_customer_email(url, win)
def send_win_customer_email(self, win):
customer_email_dict = self.make_customer_email_dict(win)
send_mail(
customer_email_dict['subject'],
customer_email_dict['body'],
settings.FEEDBACK_ADDRESS,
customer_email_dict['to'],
html_message=customer_email_dict['html_body'],
)
customer_notification = Notification(
type=Notification.TYPE_CUSTOMER,
win=win,
recipient=customer_email_dict['to'][0],
)
customer_notification.save()
# mark win complete
win.complete = True
win.save()
def send_officer_email(self, win):
officer_email_dict = generate_officer_email(win)
officer_email_dict['to'] = win.target_addresses
send_mail(
officer_email_dict['subject'],
officer_email_dict['body'],
settings.SENDING_ADDRESS,
officer_email_dict['to'],
)
for officer_email in officer_email_dict['to']:
officer_notification = Notification(
type=Notification.TYPE_OFFICER,
win=win,
recipient=officer_email,
)
officer_notification.save()
def handle(self, *args, **options):
if options['ids']:
given_win_ids = [w.replace('-', '')
for w in options['ids'].split(',')]
wins = self.thing(given_win_ids)
elif options['change_ids']:
idemails = options['change_ids']
id_emails = [idemail.split(':')
for idemail in idemails.split(',') if idemail]
id_to_email = {
wid.replace('-', ''): email.lower()
for wid, email in id_emails
}
wins = self.thing(list(id_to_email.keys()))
for win in wins:
win_id = str(win.id)
new_customer_email = id_to_email[win_id.replace('-', '')]
if win.customer_email_address != new_customer_email:
print(
'win', win_id,
'changing email from ',
win.customer_email_address,
'to',
new_customer_email,
'new email sent'
)
win.customer_email_address = new_customer_email
win.save()
else:
print('win', win_id, 'customer email unchanged, email re-sent')
else:
assert False, 'no valid flag given'
for win in wins:
self.send_win_customer_email(win)
self.send_officer_email(win)
|
'''
*
* Copyright [2011] [Red Hat, Inc.]
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
'''
import logging
import os
import time
LOGGER = logging.getLogger('Audrey')
from audrey.errors import AAError
from audrey.shell import get_system_info
CLOUD_INFO_FILE = '/etc/sysconfig/cloud-info'
def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):
"""Retry calling the decorated function using an exponential backoff.
http://www.saltycrane.com/blog/2009/11/trying-out-retry-decorator-python/
original from: http://wiki.python.org/moin/PythonDecoratorLibrary#Retry
:param ExceptionToCheck: the exception to check. may be a tuple of
excpetions to check
:type ExceptionToCheck: Exception or tuple
:param tries: number of times to try (not retry) before giving up
:type tries: int
:param delay: initial delay between retries in seconds
:type delay: int
:param backoff: backoff multiplier e.g. value of 2 will double the delay
each retry
:type backoff: int
:param logger: logger to use. If None, print
:type logger: logging.Logger instance
"""
def deco_retry(f):
def f_retry(*args, **kwargs):
mtries, mdelay = tries, delay
try_one_last_time = True
while mtries > 1:
try:
return f(*args, **kwargs)
try_one_last_time = False
break
except ExceptionToCheck, e:
msg = "%s, Retrying in %d seconds..." % (str(e), mdelay)
if logger:
logger.warning(msg)
else:
print msg
time.sleep(mdelay)
mtries -= 1
mdelay *= backoff
if try_one_last_time:
return f(*args, **kwargs)
return
return f_retry # true decorator
return deco_retry
def _get_cloud_type():
'''
Description:
Get the type of the cloud back end this instance is running on.
Currently utilizes Puppet's facter via a Python subprocess call.
Currently supported cloud back end types are:
EC2, RHEV, VSPHERE
Input:
None
Returns:
One of the following strings:
'EC2', 'RHEV', 'VSPHERE' or 'UNKNOWN'
'''
system_facts = get_system_info(['productname', 'ec2_ami_id'])
# Check for productname key as found on RHEVm and VMware/vSphere
if 'productname' in system_facts:
if 'RHEV' in system_facts['productname'].upper():
return 'RHEV'
if 'VMWARE' in system_facts['productname'].upper():
return 'VSPHERE'
# Check for ec2_ami_id key as found on EC2
if 'ec2_ami_id' in system_facts:
return 'EC2'
return 'UNKNOWN'
@retry(Exception, tries=4)
def discover():
'''
Description:
User Data is passed to the launching instance which
provides the Config Server contact information.
Cloud providers expose the user data differently.
It is necessary to determine which cloud provider
the current instance is running on to determine
how to access the user data. Images built with
image factory will contain a CLOUD_INFO_FILE which
contains a string identifying the cloud provider.
Images not built with Imagefactory will try to
determine what the cloud provider is based on system
information.
'''
LOGGER.debug('Invoked discover')
if os.path.exists(CLOUD_INFO_FILE):
cloud_info = open(CLOUD_INFO_FILE)
cloud_type = cloud_info.read().strip().upper()
cloud_info.close()
else:
cloud_type = _get_cloud_type()
LOGGER.debug('cloud_type: ' + str(cloud_type))
if 'EC2' in cloud_type:
import audrey.user_data_ec2
return audrey.user_data_ec2.UserData()
elif 'RHEV' in cloud_type:
import audrey.user_data_rhev
return audrey.user_data_rhev.UserData()
elif 'VSPHERE' in cloud_type:
import audrey.user_data_vsphere
return audrey.user_data_vsphere.UserData()
else:
raise AAError('Cloud type "%s" is invalid.' % cloud_type)
class UserDataBase(object):
'''
Description:
Discover the Config Server access info.
If not discover it using the cloud provider specific method.
'''
ud_version = 0
endpoint = ''
oauth_key = ''
oauth_secret = ''
def _parse_user_data(self, data):
'''
Take a string in form version|[value|][value|][value|]...
parses according to version and populate the respective self var.
Conductor puts the UUID into the oauth_key field.
At minimum this function expects to find a | in the string
this is in effort not to log oauth secrets.
'''
LOGGER.debug('Parsing User Data')
user_data = data.split('|')
if len(user_data) > 1:
if user_data[0] == '1':
# version 1
# format version|endpoint|oauth_key|oauth_secret
ud_version, endpoint, \
oauth_key, oauth_secret = user_data
self.ud_version = ud_version
self.endpoint = endpoint
self.oauth_key = oauth_key
self.oauth_secret = oauth_secret
return {'endpoint': self.endpoint,
'oauth_key': self.oauth_key,
'oauth_secret': self.oauth_secret, }
else:
raise AAError('Invalid User Data Version: %s' % user_data[0])
else:
raise AAError('Could not get user data version, parse failed')
def read(self):
'''
Dummy function, indended to be overridden
should return (endpoint, oauth_jey, oauth_secret)
'''
raise AAError("%s read() not overridden. Execution Aborted" % self)
|
#!/usr/bin/env python
import asyncio
import logging
logger = logging.getLogger("chatkit:" + __name__)
class WSClientManager:
def __init__(self):
self._clients = []
def all(self):
return self._clients
def add(self, client):
logging.info("+ WSClient {}".format(client))
self._clients.append(client)
def remove(self, client):
logging.info("- WSClient {}".format(client))
self._clients.remove(client)
class WSClient:
objects = WSClientManager()
def __init__(self, server, ws, user=None, token=None):
self.server = server
self._ws = ws
self.user = user
self.token = token
WSClient.objects.add(self)
@asyncio.coroutine
def disconnect(self, message):
self.server.disconnect(self, message)
@asyncio.coroutine
def send(self, data):
if self._ws.state != "OPEN":
logging.info("WS state not OPEN, disconnecting" +
str(self.user))
self.disconnect("WS state not OPEN.")
return
logging.info("> {} {}".format(self.user, data))
yield from self._ws.send(data)
@asyncio.coroutine
def send_one(self, to_client, data):
if to_client._ws.state != "OPEN":
to_client.disconnect("WS state not OPEN.")
yield from to_client._ws.send(data)
logging.info("> {} {}".format(to_client.user, data))
@asyncio.coroutine
def send_all(self, from_client, data):
for c in WSClient.clients:
yield from self.send_one(c, data)
@asyncio.coroutine
def send_others(self, from_client, data):
for c in WSClient.clients:
if c != from_client:
yield from self.send_one(c, data)
@asyncio.coroutine
def get_others(self, client):
for c in WSClient.clients:
resp = "join {}".format(c.user.username)
yield from self.send_one(self, resp)
|
'''
Copyright 2009, 2010 Anthony John Machin. All rights reserved.
Supplied subject to The GNU General Public License v3.0
Created on 28 Jan 2009
Last Updated on 10 July 2010
As test20 with tests of:
rules instantiation and query inference
Related:
single dict TS recursion rule plus generic rule + minimal data:
test20simple-001d - unmerged recursive rule EQ order correct QL order correct
test20simple-002d - unmerged recursive rule EQ order correct QL order incorrect
test20simple-003d - merged recursive rule EQ order correct QL order correct variables consistent
test20simple-004d - merged recursive rule EQ order correct QL order correct variables inconsistent (03)
test20simple-005d - merged recursive rule EQ order correct QL order incorrect variables consistent
test20simple-006d - merged recursive rule EQ order correct QL order incorrect variables inconsistent (04)
test20simple-007d - unmerged recursive rule EQ order incorrect QL order correct (05)
test20simple-008d - unmerged recursive rule EQ order incorrect QL order incorrect (06)
test20simple-009d - merged recursive rule EQ order incorrect QL order correct variables consistent
test20simple-010d - merged recursive rule EQ order incorrect QL order correct variables inconsistent (07)
test20simple-011d - merged recursive rule EQ order incorrect QL order incorrect variables consistent
test20simple-012d - merged recursive rule EQ order incorrect QL order incorrect variables inconsistent (08)
single rbtree TS recursion rule plus generic rule + minimal data:
test20simple-001r - unmerged recursive rule EQ order correct QL order correct
test20simple-002r - unmerged recursive rule EQ order correct QL order incorrect
test20simple-003r - merged recursive rule EQ order correct QL order correct variables consistent
test20simple-004r - merged recursive rule EQ order correct QL order correct variables inconsistent (03)
test20simple-005r - merged recursive rule EQ order correct QL order incorrect variables consistent
test20simple-006r - merged recursive rule EQ order correct QL order incorrect variables inconsistent (04)
test20simple-007r - unmerged recursive rule EQ order incorrect QL order correct (05)
test20simple-008r - unmerged recursive rule EQ order incorrect QL order incorrect (06)
test20simple-009r - merged recursive rule EQ order incorrect QL order correct variables consistent
test20simple-010r - merged recursive rule EQ order incorrect QL order correct variables inconsistent (07)
test20simple-011r - merged recursive rule EQ order incorrect QL order incorrect variables consistent
test20simple-012r - merged recursive rule EQ order incorrect QL order incorrect variables inconsistent (08)
@author: Administrator
'''
import metabulate.stores.stores as mtstores
import metabulate.facades.facade as mtfacade
import metabulate.utils.utils as mtutils
import metabulate.utils.debug as mtdebug
import metabulate.renderers.render as mtrender
import metabulate.rules.rules as mtrules
import metabulate.singletons.singleton as mtsingleton
if __name__ == "__main__":
# get default file paths and types
mtconfig = mtsingleton.Settings()._getItem('config')
debug_path = mtconfig._getItem('debugfile_path','%configfilesbase%Debug\\',mtconfig)
debug_type = mtconfig._getItem('debugfile_type','txt',mtconfig)
result_path = mtconfig._getItem('resultsfile_path','%configfilesbase%Results\\',mtconfig)
result_type = mtconfig._getItem('resultsfile_type','txt',mtconfig)
unload_path = mtconfig._getItem('stores_unloadfile_path','%configfilesbase%Unloads\\',mtconfig)
unload_type = mtconfig._getItem('stores_unloadfile_type','pyo',mtconfig)
# set debug criteria
dc22f = mtdebug.Criteria(methods=['_actionPredicate','_actionTriple','_processTriple','_addTriple'],
targets=[mtutils.Flatfile(path=debug_path,
name='DebugOutput_dc22',
type=debug_type)])
dc28 = mtdebug.Criteria(classes=['Query'],methods=['_solve'],notes=['trace'])
# set debug
# d = mtdebug.Debug()
# assign it the criteria
# d._update(criteria=[dc8f,dc12f,dc7f,dc13f,dc10f,dc14f,dc15f])
# d._update(criteria=[dc6,dc20f_dup,dc20f_ok])
# d._update(criteria=[dc11f])
# d._update(criteria=[dc21f])
# d._update(criteria=[dc6,dc20f])
# files
fu = mtutils.Flatfile(path=unload_path,
name='test20r-30_unload_s1',
type=unload_type)
f1 = mtutils.Flatfile(path=result_path,
name='genealogy_test1',
type=result_type)
f3 = mtutils.Flatfile(path=result_path,
name='test20r-30_triples',
type=result_type)
f4 = mtutils.Flatfile(path=result_path,
name='test20r-30_rules',
type=result_type)
f5 = mtutils.Flatfile(path=result_path,
name='test20r-30_queries',
type=result_type)
f6 = mtutils.Flatfile(path=result_path,
name='test20r-30_results',
type=result_type)
# stores
sa = mtstores.TripleStore(structure='dict') # TS sa dict
sr = mtstores.TripleStore() # TS sr
s2 = mtstores.TripleStore()
s3 = mtstores.TripleStore()
s4 = mtstores.TripleStore()
# add namespaces in source stores
sa._addNamespace('mytriples', 'http://www.semanticle.org/triples/')
sa._addNamespace('comtriples', 'http://www.semanticle.com/triples/')
# triples for recursion test
sa._actionTriple("add [('mytriples#bob', 'child_of', 'alice'),('http://www.semanticle.com/triples/#dan', 'child_of', 'cev')]")
sa._actionTriple("add", [('cev', 'child_of', 'http://www.semanticle.org/triples/#bob'),"('http://www.semanticle.com/triples/#dan', 'child_of', 'cev')"])
sa._actionTriple("add", 'eve', 'child_of', 'comtriples#dan')
# sa._actionTriple("add",{('?desc', 'desc_of', '?ancs'):
# [
# [[('?desc', 'child_of', '?ancs')]]
# ,[[('?child', 'child_of', '?ancs')],[('?desc', 'desc_of', '?child')]]
# ,[[('?desc', 'desc_of', '?child')],[('?child', 'child_of', '?ancs')]]
# ]})
sa._actionTriple("add ('?desc', 'desc_of', '?ancs') :- [[[('?desc', 'child_of', '?ancs')]]]") # add rule clause 1 to DTS._queryStore b (or change to DTS s1)
sa._actionTriple("add",{('?obj', '?inv', '?sub'):
[
[[('?inv', 'rev_of', '?forw'),('?forw', 'rev_of', '?inv')]
,[('?sub', "?forw", '?obj')]]
,[[('?inv', 'syn_of', '?inv1'),('?inv1', 'syn_of', '?inv')]
,[('?obj', "?inv1", '?sub')]]
]}) # add rule to DTS._queryStore a (or change to DTS s1)
sa._actionTriple("add","{('?desc1', 'desc_of', '?ancs'):[[[('?child', 'child_of', '?ancs')],[('?desc1', 'desc_of', '?child')]]]}") # add rule clause 2 to DTS._queryStore b (or change to DTS s1)
# sa._actionTriple("add","{('?desc1', 'desc_of', '?ancs'):[[[('?desc1', 'desc_of', '?child')],[('?child', 'child_of', '?ancs')]]]}") # add rule clause 2 to DTS._queryStore b (or change to DTS s1)
sa._actionTriple("add", 'ancs_of', 'rev_of', 'desc_of') # ant
# s1._actionTriple("add", 'desc_of', 'rev_of', 'ancsr_of') # rev ant
sa._actionTriple("add", 'des_of', 'syn_of', 'desc_of') # syn
# s1._actionTriple("add", 'desc_of', 'syn_of', 'descr_of') # rev syn
sa._actionTriple("add", 'anc_of', 'rev_of', 'des_of') # ant of syn
# s1._actionTriple("add", 'ancestor1_of', 'syn_of', 'ancs_of') # syn of ant
sa._actionTriple("add", 'ancestor2_of', 'syn_of', 'anc_of') # syn of ant of syn
# s1._actionTriple("add", 'ancestor3_of', 'syn_of', 'ancestor2_of') # syn of syn of ant of syn
# triples for nested rules test
# s1._actionTriple("add", 'bob', 'is_sex', 'male')
# s1._actionTriple("add", 'cev', 'is_sex', 'male')
# s1._actionTriple("add", 'dan', 'is_sex', 'male')
# s1._actionTriple("add", 'eve', 'is_sex', 'female')
# s1._actionTriple("add", 'nancy', 'mother_of', 'mike')
# s1._actionTriple("add", 'niel', 'father_of', 'mike')
# s1._actionTriple("add", 'mike', 'is_sex', 'male')
# s1._actionPredicate(action="add",
# fact=('?child', 'son_of', '?parent'),
# rule=[[[('?child', 'child_of', '?parent')],
# [('?child', "'is_sex'", "'male'")]]])
# s1._actionPredicate(action="add",
# fact=('?child', 'child_of', '?parent'),
# rule=[[[('?parent', 'father_of', '?child')]],
# [[('?parent', "'mother_of'", '?child')]]])
# Test Load/Unload
# s1._unload(file=f1)
# s0 = s1._load(file=f1)
# print (s0._toString())
# print
print (sa._toString())
# print
# print ('unloading DSTS s1 to fu')
# sa._unload()
# print ('reloading DSTS from fu as sr')
# sr = sr._load()
# print
# print (sr._toString())
# print
# print (s0._toString())
# d = mtdebug.Debug()
# assign it the criteria
# d._update(criteria=[dc19f])
# set Result requests
# rlt04 = mtrules.Result(request=[[('?sub=eve','?pred=child_of','?obj=dan')]]) # pass
# rlt04 = mtrules.Result(request=[[("?sub='*'","?pred='*'","?obj='*'")]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub="*"','?pred="*"','?obj="*"')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub="?"','?pred','?obj="?"')]]) # FAIL - NO RULES RETURNED (MAYBE OK?)
# rlt04 = mtrules.Result(request=[[("?sub='?'","?pred","?obj='?'")]]) # FAIL - NO RULES RETURNED (MAYBE OK?)
# rlt04 = mtrules.Result(request=[[('?sub=eve', "?pred=desc_of", '?obj=alice')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub=eve', "?pred=des_of", '?obj=alice')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub', "?pred=desc_of", '?obj')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub', "?pred=ancs_of", '?obj')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub', "?pred=des_of", '?obj')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub=?','?pred','?obj')
# ,('?sub','?pred=?','?obj')
# ,('?sub','?pred','?obj=?')]]) # pass - all inferences
# rlt04 = mtrules.Result(request=[[('?sub == ?','?pred','?obj')
# ,('?sub','?pred = =?','?obj')
# ,('?sub','?pred','?obj==?')]]) # pass - all rules
rlt04 = mtrules.Result(request=[[('?sub','?pred','?obj')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub','?pred','?obj')],[('?sub','child_of','dan')]]) # FAIL
# rlt04 = mtrules.Result(request=[[('?sub','?pred','?obj')],['not',('?sub','child_of','dan')]]) # pass
# rlt04 = mtrules.Result(request=[['not',('?sub','child_of','comtriples#dan')],[('?sub','?pred','?obj')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub','?pred','?obj')],['not',('?sub','child_of','dan')]
# ,['not',('?sub','from','London')]]) # pass
# rlt04 = mtrules.Result(request=[[('?sub','?pred=ancestor3_of','?obj')]]) # pass
rlt05 = mtrules.Result(request=[[("?s","?r=?r1='child_of'","?o")]]) # pass
# rlt02 = mtrules.Result(request=[[('eve', "desc_of", '?person2')]]) # pass
# rlt02 = mtrules.Result(request=[[(('ender', 'from', 'Truro'), "desc_of", '?person2')]]) # pass
# rlt02 = mtrules.Result(request=[[(('ender|eddy', 'from', 'Truro'), "desc_of", '?person2')]]) # pass
# rlt02 = mtrules.Result(request=[[(('?person1', 'from', 'Truro'), "desc_of", '?person2')]]) # pass
# rlt02 = mtrules.Result(request=[[('eve', "desc_of", '?person2')]
# ,[('?person2', "desc_of", 'alice')]]) # pass
# rlt02 = mtrules.Result(request=[[('eve', "des_of", '?person2')]
# ,[('?person2', "des_of", 'alice')]]) # pass - syn of recursed rule
# rlt02 = mtrules.Result(request=[[('eve', "descr_of", '?person2')]
# ,[('?person2', "descr_of", 'alice')]]) # pass - reversed syn of recursed rule
# rlt02 = mtrules.Result(request=[[('alice', "ancs_of", '?person2')]
# ,[('?person2', "ancs_of", 'eve')]]) # pass - ant of recursed rule
# rlt02 = mtrules.Result(request=[[('alice', "ancsr_of", '?person2')]
# ,[('?person2', "ancsr_of", 'eve')]]) # pass - reversed ant of recursed rule
# rlt02 = mtrules.Result(request=[[('alice', "anc_of", '?person2')]
# ,[('?person2', "anc_of", 'eve')]]) # pass - ant of syn of recursed rule
# rlt02 = mtrules.Result(request=[[('alice', "ancestor1_of", '?person2')]
# ,[('?person2', "ancestor1_of", 'eve')]]) # pass - syn of ant of recursed rule
rlt02 = mtrules.Result(request=[[('alice', "ancestor2_of", '?person2')]
,[('?person2', "ancestor2_of", 'eve')]]) # pass - syn of ant of syn of recursed rule
# rlt02 = mtrules.Result(request=[[('alice', "ancestor3_of", '?person2')]
# ,[('?person2', "ancestor3_of", 'eve')]]) # pass - syn of syn of ant of syn of recursed rule
print ('queries defined')
# rendering submission
p0t = mtrender.Sequence(pattern=['?!triples'], # via variable notation
targets=[s3,f3],
render='py')
p0r = mtrender.Sequence(pattern=['?!rules'], # via variable notation
targets=[s4,f4],
render='py')
p0q = mtrender.Sequence(pattern=['?!queries'], # via variable notation
targets=[f5],
render='py')
p1 = mtrender.Sequence(pattern=[('?son', 'son_of', '?person')], # triple propogation
targets=[s2,'display'],
render='csv')
p2 = mtrender.Sequence(pattern=[('?person1', 'desc_of', '?person2')], # triple propogation
targets=[s2,'display'],
render='csv')
p3 = mtrender.Sequence(pattern=['?person2'],
targets=['display'],
render='csv')
p4 = mtrender.Sequence(pattern=[('?sub', '?pred', '?obj')],
targets=[s2,'display'],
render='csv',
URImode='nativealias')
p4a = mtrender.Sequence(pattern=[('?sub', '?pred', '?obj'),('results', 'contain', ('?sub', '?pred', '?obj'))],
targets=[s2,'display'],
render='csv',
URImode='nativealias')
p6 = mtrender.Transformation(pattern=['!!og!!','/^(.)(.*?)(.)$/$3$2$1/'],id='?p6')
#p5 = mtrender.Sequence(pattern=[({('np2',p2):{'og':'?o'}},'is known by','?s')])
p5 = mtrender.Sequence(pattern=[({('np6','!p6'):{'?og':'?o'}},'is known by','?s')],
targets=['display'],
render='csv')
print ('Renders defined')
# d = mtdebug.Debug()
# assign it the criteria
# d._update(criteria=[dc16f])
# set query
rlt02._update(outputs=[p3])
face02 = mtfacade.Facade(store=sa,
results=[rlt02])
# rlt04._update(outputs=[p4,p0t,p0r,p0q])
rlt04._update(outputs=[p4])
face04 = mtfacade.Facade(store=sa,
results=[rlt04])
rlt05._update(outputs=[p5])
face05 = mtfacade.Facade(store=sa,
results=[rlt05])
print ('results and facades defined')
# reset dubug criteria
# execute the query
# s1._update(infer=False)
face04._generate()
print
# check output channelled to a store
print ('results instantiated')
print (s2._toString())
print ('should be 60 results')
print
print ('contributory triples instantiated')
print (s3._toString())
print ('contributory rules instantiated')
print (s4._toString())
# print ('source Store again')
# print (sr._toString())
|
"""Parse Suffolk County data file and emit OpenElections CSV.
@author [email protected]
@date 2017-07-11
"""
import sys
def parse_information_record(line):
"""Type I. Read and parse information record data."""
information = line[5:].rstrip()
return {'information': information}
def parse_office_record(line):
"""Type R. Read and parse office record data."""
office_title = line[5:45].rstrip()
office_title_std = office_title.replace(',', '')
office_district_type = line[45:46].rstrip()
try:
office_district_number = int(line[46:50])
except ValueError:
office_district_number = ''
if office_district_number == 0:
office_district_number = ''
opp_to_ballot = line[50:51]
num_election_districts = int(line[51:55])
count_eligible_voters = int(line[55:62])
try:
num_candidates = int(line[62:64])
except ValueError:
num_candidates = 0
opp_to_ballot_lookup = {'Y': True,
'N': False,
' ': 'Unknown',
'O': 'Unknown',
'0': 'Unknown',
'2': 'Unknown'}
district_type_lookup = {'U': 'United States',
'N': 'New York State',
'K': 'Suffolk County',
'A': 'Unknown',
'L': 'Unknown',
'T': 'Unknown',
'W': 'Unknown',
'S': 'Unknown',
'J': 'Unknown',
'X': 'Unknown',
'C': 'Unknown'}
return {'office_title': office_title,
'office_title_std': office_title_std,
'office_district_type': district_type_lookup[office_district_type],
'office_district_number': office_district_number,
'opp_to_ballot': opp_to_ballot_lookup[opp_to_ballot],
'num_election_districts': num_election_districts,
'count_eligible_voters': count_eligible_voters,
'num_candidates': num_candidates}
def parse_candidate_record(line):
"""Type C. Read and parse candidate record data."""
candidate_name = line[5:30].rstrip().title()
candidate_name_std = candidate_name
if ', ' in candidate_name:
# Re-order 'Smith, Bob' as 'Bob Smith'
names = candidate_name.split(', ')
candidate_name_std = "{} {}".format(names[1], names[0])
party_code = line[30:33].rstrip()
write_in_flag = line[33:34]
write_in_lookup = {'S': True, ' ': 'Unknown'}
total_votes = int(line[34:41])
row_lever_on_ballot = line[41:44].rstrip()
return {'candidate_name': candidate_name,
'candidate_name_std': candidate_name_std,
'party_code': party_code,
'write_in_flag': write_in_lookup[write_in_flag],
'total_votes': total_votes,
'row_lever_on_ballot': row_lever_on_ballot}
def parse_ed_record(line):
"""Type E. Read ED-result record data."""
record_length = int(line[:4])
town_code = line[5:6]
town_code_lookup = {'0': 'Shelter Island',
'1': 'Brookhaven',
'2': 'Huntington',
'3': 'Islip',
'4': 'Babylon',
'5': 'Smithtown',
'6': 'Southampton',
'7': 'East Hampton',
'8': 'Southold',
'9': 'Riverhead'}
ed_number = int(line[6:9])
reported_status = line[9:10].rstrip()
eligible_voters = int(line[10:14])
try:
whole_number = int(line[14:20])
except ValueError:
whole_number = 0
congress_district = int(line[34:35])
senate_district = int(line[35:36])
assembly_district = int(line[36:38])
legislative_district = int(line[38:40])
towncouncil_district = line[40:42].rstrip()
try:
blank_votes = int(line[42:46])
except ValueError:
blank_votes = 0
void_votes = int(line[46:49])
try:
scattering_votes = int(line[49:52])
except ValueError:
scattering_votes = 0
# Handle variable-length candidate fields
num_candidates = (record_length - 52) / 4
if num_candidates % 1 != 0:
raise ValueError("Incorrect number of characters on line.")
votes = []
try:
for i in range(int(num_candidates)):
start_index = 52 + (4 * i)
end_index = 56 + (4 * i)
votes.append(int(line[start_index:end_index]))
except TypeError as t:
print("Caught TypeError with num_candidates {}, record_length {}, "
"line '{}'".format(num_candidates, record_length, line))
# Generate Suffolk-specific precinct code
precinct_code = "{} #: {:>3}".format(town_code_lookup[town_code].title(),
"{:02.0f}".format(ed_number))
return {'town_name': town_code_lookup[town_code],
'ed_number': ed_number,
'reported_status': reported_status,
'eligible_voters': eligible_voters,
'whole_number': whole_number,
'congress_district': congress_district,
'senate_district': senate_district,
'assembly_district': assembly_district,
'legislative_district': legislative_district,
'towncouncil_district': towncouncil_district,
'blank_votes': blank_votes,
'void_votes': void_votes,
'scattering_votes': scattering_votes,
'num_candidates': num_candidates,
'votes': votes,
'precinct_code': precinct_code}
def process_file(filename):
"""Read the whole file and emit output in standard OE format."""
out_handle = open("{}-output.csv".format(filename), 'w')
out_handle.write('county,precinct,office,district,party,candidate,votes\n')
candidates = None
office = None
in_handle = open(filename, 'r')
for line in in_handle:
if line[4:5] == 'I':
# Information
print(parse_information_record(line))
if line[4:5] == 'R':
# Office
office = parse_office_record(line)
# Reset candidates
candidates = []
if line[4:5] == 'C':
# Candidate
candidates.append(parse_candidate_record(line))
if line[4:5] == 'E':
# ED Breakdown
election_district = parse_ed_record(line)
for i, vote in enumerate(election_district['votes']):
# County
output = ['Suffolk']
# Precinct
output.append(election_district['precinct_code'])
# Office
output.append(office['office_title_std'])
# District
output.append(str(office['office_district_number']))
# Party
try:
output.append(candidates[i]['party_code'])
except IndexError:
output.append('')
# Candidate
try:
output.append(candidates[i]['candidate_name_std'])
except IndexError:
output.append('')
# Votes
output.append(str(vote))
out_handle.write(",".join(output))
out_handle.write("\n")
# Append ED void/scattering votes
special_types = {'Scattering': 'scattering_votes',
'Void': 'void_votes',
'Blank': 'blank_votes'}
for name in special_types:
if election_district[special_types[name]] > 0:
output = ['Suffolk',
election_district['precinct_code'],
office['office_title_std'],
str(office['office_district_number']),
'',
name,
str(election_district[special_types[name]])]
out_handle.write(",".join(output))
out_handle.write("\n")
in_handle.close()
out_handle.close()
if __name__ == "__main__":
if len(sys.argv) < 2:
sys.exit("Provide filename on command-line.")
else:
process_file(sys.argv[1])
|
from setuptools import setup, find_packages
#from Cython.Build import cythonize
import numpy as np
import os, sys, glob
__version__ = '0.2' #this needs to be kept up to date with shapelets/__init__.py
setup(name = 'shapelets',
version = __version__,
description = 'Shapelet fitting and plotting',
long_description = 'Shapelet fitting and plotting',
author = 'Griffin Foster',
author_email = '[email protected]',
url = 'https://github.com/griffinfoster/shapelets',
platforms = ['*nix'],
license='GPL',
requires = ['distutils', 'numpy', 'astropy', 'scipy', 'matplotlib', 'json'],
provides = ['shapelets', 'shapelets.phs'],
packages = ['shapelets', 'shapelets.phs'],
#ext_modules = cythonize('shapelets/cshapelet.pyx', annotate=True),
include_dirs = [np.get_include()],
#scripts = glob.glob('scripts/*.py'),
scripts = ['scripts/fitShapelet.py', 'scripts/insertShapelet.py', 'scripts/plotCoeffs.py', 'scripts/plotImg.py', 'scripts/plotShapelets.py', 'scripts/solveShapelet.py'],
classifiers = [
'Development Status :: 4 - Beta',
'Environment :: Console',
'Natural Language :: English',
'Operating System :: POSIX :: Linux',
'Programming Language :: Python :: 2.7',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: GNU General Public License (GPL)',
'Topic :: Scientific/Engineering :: Astronomy',
],
)
|
from django.db import models
from django.template import loader
import requests
class AdSource(models.Model):
name = models.CharField(max_length=10)
get_url = models.URLField()
def fetch_ad_domains(self):
url = self.get_url
response = requests.get(url)
if response.status_code == 200:
response_list = str(response.content, 'UTF-8')\
.replace('\r','').split('\n')
ad_list = []
for line in response_list:
a = line.replace('\t', ' ').split(' ')
if a[0] != '#' and a[0] in ['0.0.0.0', '127.0.0.1'] and a[1] not in ('', 'localhost') and a[1][-1] != '.':
ad_list.append(a[1].lower())
elif len(a) > 1 and len(a[1]) > 1 and a[1][-1] == '.':
print('Rejected : {}'.format(line))
ad_domains = self.ad_domains.all()
for ad_domain in ad_domains:
ad_domain.delete()
for ad_domain in ad_list:
print(ad_domain)
self.ad_domains.create(domain=ad_domain)
class AdDomain(models.Model):
domain = models.CharField(max_length=100)
source = models.ForeignKey(AdSource, related_name='ad_domains')
@classmethod
def get_ad_blacklist(cls):
ad_list = cls.objects.values('domain').distinct()
string = loader.render_to_string('named/badlist.txt', {
'blackhole': 'dns1.bancuh.com',
'ad_list': ad_list
})
return string
|
from .resource import Resource
#
# The MIT License (MIT)
#
# Copyright (C) 2014 hellosign.com
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
class ApiApp(Resource):
''' Contains information about an API App.
Attributes:
client_id (str): The API App's Client ID
created_at (int): Unix timestamp of when the API App was created
name (str): The name of the API App
domain (str): The domain name associated with the API App
callback_url (str) : The URL that HelloSign events will be POSTed to
is_approved (bool): Indicates if the API App is approved
owner_account (dict): Information about the API App owner
account_id (str): The id of the Account
email_address (str): The email address associated with the Account
options (dict): Options that override the Account settings
can_insert_everywhere (bool): Denotes if signers can "Insert Everywhere" when
signing a document
oauth (dict): Information about the API App's OAuth properties. Null if OAuth is
not configured for the API App.
callback_url (str): The URL that HelloSign OAuth events will be POSTed to
secret (str): The API App's OAuth secret
scopes (list): List of the API App's OAuth scopes
charges_users (bool): Indicates whether the API App or the authorized user
is billed for OAuth requests.
white_labeling_options (dict): Customization options for the API App's signer page
Examples:
To print the client_id
>>> from hsclient import HSClient
>>> client = HSClient()
>>> app = client.get_api_app_info()
>>> print app.client_id
'''
def __init__(self, jsonstr=None, key=None, warnings=None):
''' Initialization of the object
Args:
jsonstr (str): a raw JSON string that is returned by a request.
We store all the data in `self.json_data` and use `__getattr__`
and `__setattr__` to make the data accessible like attributes
of the object
key (str): Optional key to use with jsonstr. If `key` exists, we'll
load the data of `jsonstr[key]` instead of the whole `jsonstr`
warnings (list): List of associated warnings
'''
super(ApiApp, self).__init__(jsonstr, key, warnings)
def __str__(self):
''' Return a string representation of this Account '''
return 'ApiApp %s (%s)' % (self.name, self.client_id)
|
import os
import re
import codecs
import numpy as np
import theano
models_path = "./models"
eval_path = "./evaluation"
eval_temp = os.path.join(eval_path, "temp")
eval_script = os.path.join(eval_path, "conlleval")
def get_name(parameters):
"""
Generate a model name from its parameters.
"""
l = []
for k, v in parameters.items():
if type(v) is str and "/" in v:
l.append((k, v[::-1][:v[::-1].index('/')][::-1]))
else:
l.append((k, v))
name = ",".join(["%s=%s" % (k, str(v).replace(',', '')) for k, v in l])
return "".join(i for i in name if i not in "\/:*?<>|")
def set_values(name, param, pretrained):
"""
Initialize a network parameter with pretrained values.
We check that sizes are compatible.
"""
param_value = param.get_value()
if pretrained.size != param_value.size:
raise Exception(
"Size mismatch for parameter %s. Expected %i, found %i."
% (name, param_value.size, pretrained.size)
)
param.set_value(np.reshape(
pretrained, param_value.shape
).astype(np.float32))
def shared(shape, name):
"""
Create a shared object of a numpy array.
"""
if len(shape) == 1:
value = np.zeros(shape) # bias are initialized with zeros
else:
drange = np.sqrt(6. / (np.sum(shape)))
value = drange * np.random.uniform(low=-1.0, high=1.0, size=shape)
return theano.shared(value=value.astype(theano.config.floatX), name=name)
def create_dico(item_list):
"""
Create a dictionary of items from a list of list of items.
"""
assert type(item_list) is list
dico = {}
for items in item_list:
for item in items:
if item not in dico:
dico[item] = 1
else:
dico[item] += 1
return dico
def create_mapping(dico):
"""
Create a mapping (item to ID / ID to item) from a dictionary.
Items are ordered by decreasing frequency.
"""
sorted_items = sorted(dico.items(), key=lambda x: (-x[1], x[0]))
id_to_item = {i: v[0] for i, v in enumerate(sorted_items)}
item_to_id = {v: k for k, v in id_to_item.items()}
return item_to_id, id_to_item
def zero_digits(s):
"""
Replace every digit in a string by a zero.
Bill: replace the url as well
"""
sep = s.find('\t')
#s = re.sub('\d', '0', s[0:sep])+s[sep:]
s = re.sub('[0-9]\d*', '0', s[0:sep]) + s[sep:]
s = re.sub(r'\w+:\/{2}[\d\w-]+(\.[\d\w-]+)*(?:(?:\/[^\s/]*))*', '1', s)
return s
def iob2(tags):
"""
Check that tags have a valid IOB format.
Tags in IOB1 format are converted to IOB2.
"""
for i, tag in enumerate(tags):
if tag == 'O':
continue
split = tag.split('-')
if len(split) != 2 or split[0] not in ['I', 'B']:
return False
if split[0] == 'B':
continue
elif i == 0 or tags[i - 1] == 'O': # conversion IOB1 to IOB2
tags[i] = 'B' + tag[1:]
elif tags[i - 1][1:] == tag[1:]:
continue
else: # conversion IOB1 to IOB2
tags[i] = 'B' + tag[1:]
return True
def iob_iobes(tags):
"""
IOB -> IOBES
"""
new_tags = []
for i, tag in enumerate(tags):
if tag == 'O':
new_tags.append(tag)
elif tag.split('-')[0] == 'B':
if i + 1 != len(tags) and \
tags[i + 1].split('-')[0] == 'I':
new_tags.append(tag)
else:
new_tags.append(tag.replace('B-', 'S-'))
elif tag.split('-')[0] == 'I':
if i + 1 < len(tags) and \
tags[i + 1].split('-')[0] == 'I':
new_tags.append(tag)
else:
new_tags.append(tag.replace('I-', 'E-'))
else:
raise Exception('Invalid IOB format!')
return new_tags
def iobes_iob(tags):
"""
IOBES -> IOB
"""
new_tags = []
for i, tag in enumerate(tags):
if tag.split('-')[0] == 'B':
new_tags.append(tag)
elif tag.split('-')[0] == 'I':
new_tags.append(tag)
elif tag.split('-')[0] == 'S':
new_tags.append(tag.replace('S-', 'B-'))
elif tag.split('-')[0] == 'E':
new_tags.append(tag.replace('E-', 'I-'))
elif tag.split('-')[0] == 'O':
new_tags.append(tag)
else:
raise Exception('Invalid format!')
return new_tags
def insert_singletons(words, singletons, p=0.5):
"""
Replace singletons by the unknown word with a probability p.
"""
new_words = []
for word in words:
if word in singletons and np.random.uniform() < p:
new_words.append(0)
else:
new_words.append(word)
return new_words
def pad_word_chars(words):
"""
Pad the characters of the words in a sentence.
Input:
- list of lists of ints (list of words, a word being a list of char indexes)
Output:
- padded list of lists of ints
- padded list of lists of ints (where chars are reversed)
- list of ints corresponding to the index of the last character of each word
"""
max_length = max([len(word) for word in words])
char_for = []
char_rev = []
char_pos = []
for word in words:
padding = [0] * (max_length - len(word))
char_for.append(word + padding)
char_rev.append(word[::-1] + padding)
char_pos.append(len(word) - 1)
return char_for, char_rev, char_pos
def create_input(data, parameters, add_label, singletons=None):
"""
Take sentence data and return an input for
the training or the evaluation function.
"""
words = data['words']
chars = data['chars']
if singletons is not None:
words = insert_singletons(words, singletons)
if parameters['cap_dim']:
caps = data['caps']
char_for, char_rev, char_pos = pad_word_chars(chars)
input = []
if parameters['word_dim']:
input.append(words)
if parameters['char_dim']:
input.append(char_for)
if parameters['char_bidirect']:
input.append(char_rev)
input.append(char_pos)
if parameters['pos_dim']:
input.append(data['postags'])
if parameters['dep_dim']:
input.append(data['deps'])
if parameters['ind_dim']:
input.append(data['inds'])
if parameters['head_dim']:
input.append(data['heads'])
if parameters['cap_dim']:
input.append(caps)
if add_label:
input.append(data['tags'])
return input
def evaluate(parameters, f_eval, raw_sentences, parsed_sentences,
id_to_tag, dictionary_tags):
"""
Evaluate current model using CoNLL script.
"""
n_tags = len(id_to_tag)
predictions = []
count = np.zeros((n_tags, n_tags), dtype=np.int32)
for raw_sentence, data in zip(raw_sentences, parsed_sentences):
input = create_input(data, parameters, False)
if parameters['crf']:
y_preds = np.array(f_eval(*input))[1:-1]
else:
y_preds = f_eval(*input).argmax(axis=1)
y_reals = np.array(data['tags']).astype(np.int32)
assert len(y_preds) == len(y_reals)
p_tags = [id_to_tag[y_pred] for y_pred in y_preds]
r_tags = [id_to_tag[y_real] for y_real in y_reals]
if parameters['tag_scheme'] == 'iobes':
p_tags = iobes_iob(p_tags)
r_tags = iobes_iob(r_tags)
for i, (y_pred, y_real) in enumerate(zip(y_preds, y_reals)):
new_line = " ".join(raw_sentence[i][:-1] + [r_tags[i], p_tags[i]])
predictions.append(new_line)
count[y_real, y_pred] += 1
predictions.append("")
# Write predictions to disk and run CoNLL script externally
eval_id = 23333
output_path = os.path.join(eval_temp, "eval.%i.output" % eval_id)
scores_path = os.path.join(eval_temp, "eval.%i.scores" % eval_id)
with codecs.open(output_path, 'w', 'utf8') as f:
f.write("\n".join(predictions))
os.system("%s < %s > %s" % (eval_script, output_path, scores_path))
# CoNLL evaluation results
eval_lines = [l.rstrip() for l in codecs.open(scores_path, 'r', 'utf8')]
for line in eval_lines:
print line
# Remove temp files
os.remove(output_path)
os.remove(scores_path)
'''
# Confusion matrix with accuracy for each tag
print ("{: >2}{: >7}{: >7}%s{: >9}" % ("{: >7}" * n_tags)).format(
"ID", "NE", "Total",
*([id_to_tag[i] for i in xrange(n_tags)] + ["Percent"])
)
for i in xrange(n_tags):
print ("{: >2}{: >7}{: >7}%s{: >9}" % ("{: >7}" * n_tags)).format(
str(i), id_to_tag[i], str(count[i].sum()),
*([count[i][j] for j in xrange(n_tags)] +
["%.3f" % (count[i][i] * 100. / max(1, count[i].sum()))])
)
'''
# Global accuracy
print "%i/%i (%.5f%%)" % (
count.trace(), count.sum(), 100. * count.trace() / max(1, count.sum())
)
# F1 on all entities
return float(eval_lines[1].strip().split()[-1])
def evaluate_test(parameters, f_eval, raw_sentences, parsed_sentences,
id_to_tag, dictionary_tags):
"""
Evaluate current model using CoNLL script.
"""
n_tags = len(id_to_tag)
predictions = []
count = np.zeros((n_tags, n_tags), dtype=np.int32)
for raw_sentence, data in zip(raw_sentences, parsed_sentences):
input = create_input(data, parameters, False)
if parameters['crf']:
y_preds = np.array(f_eval(*input))[1:-1]
else:
y_preds = f_eval(*input).argmax(axis=1)
y_reals = np.array(data['tags']).astype(np.int32)
assert len(y_preds) == len(y_reals)
p_tags = [id_to_tag[y_pred] for y_pred in y_preds]
r_tags = [id_to_tag[y_real] for y_real in y_reals]
if parameters['tag_scheme'] == 'iobes':
p_tags = iobes_iob(p_tags)
r_tags = iobes_iob(r_tags)
for i, (y_pred, y_real) in enumerate(zip(y_preds, y_reals)):
new_line = " ".join(raw_sentence[i][:-1] + [r_tags[i], p_tags[i]])
predictions.append(new_line)
count[y_real, y_pred] += 1
predictions.append("")
# Write predictions to disk and run CoNLL script externally
eval_id = 12345
output_path = os.path.join(eval_temp, "best_dev_test.output" )
with codecs.open(output_path, 'w', 'utf8') as f:
f.write("\n".join(predictions))
# F1 on all entities
return float(eval_lines[1].strip().split()[-1])
|
#!/usr/bin/python
# -- Content-Encoding: UTF-8 --
"""
Herald XMPP transport directory
:author: Thomas Calmant
:copyright: Copyright 2014, isandlaTech
:license: Apache License 2.0
:version: 0.0.1
:status: Alpha
..
Copyright 2014 isandlaTech
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
# Module version
__version_info__ = (0, 0, 2)
__version__ = ".".join(str(x) for x in __version_info__)
# Documentation strings format
__docformat__ = "restructuredtext en"
# ------------------------------------------------------------------------------
# Herald XMPP
from . import SERVICE_XMPP_DIRECTORY, ACCESS_ID
from .beans import XMPPAccess
# Herald
import herald
# Standard library
import logging
from pelix.ipopo.decorators import ComponentFactory, Requires, Provides, \
Property, Validate, Invalidate, Instantiate
# ------------------------------------------------------------------------------
_logger = logging.getLogger(__name__)
# ------------------------------------------------------------------------------
@ComponentFactory('herald-xmpp-directory-factory')
@Requires('_directory', herald.SERVICE_DIRECTORY)
@Property('_access_id', herald.PROP_ACCESS_ID, ACCESS_ID)
@Provides((herald.SERVICE_TRANSPORT_DIRECTORY, SERVICE_XMPP_DIRECTORY))
@Instantiate('herald-xmpp-directory')
class XMPPDirectory(object):
"""
XMPP Directory for Herald
"""
def __init__(self):
"""
Sets up the transport directory
"""
# Herald Core Directory
self._directory = None
self._access_id = ACCESS_ID
# JID -> Peer UID
self._jid_uid = {}
# Group name -> XMPP room JID
self._groups = {}
@Validate
def _validate(self, context):
"""
Component validated
"""
self._jid_uid.clear()
self._groups.clear()
@Invalidate
def _invalidate(self, context):
"""
Component invalidated
"""
self._jid_uid.clear()
self._groups.clear()
def load_access(self, data):
"""
Loads a dumped access
:param data: Result of a call to XmppAccess.dump()
:return: An XMPPAccess bean
"""
return XMPPAccess(data)
def peer_access_set(self, peer, data):
"""
The access to the given peer matching our access ID has been set
:param peer: The Peer bean
:param data: The peer access data, previously loaded with load_access()
"""
if peer.uid != self._directory.local_uid:
self._jid_uid[data.jid] = peer
def peer_access_unset(self, peer, data):
"""
The access to the given peer matching our access ID has been removed
:param peer: The Peer bean
:param data: The peer access data
"""
try:
del self._jid_uid[data.jid]
except KeyError:
pass
def from_jid(self, jid):
"""
Returns the peer UID associated to the given JID
:param jid: A peer (full) JID
:return: A peer UID
:raise KeyError: Unknown JID
"""
return self._jid_uid[jid]
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals, print_function, division, absolute_import
from django.utils.encoding import force_bytes, force_text
from django.utils.http import urlquote
import unicodedata
def create_content_disposition(filename, attachment=True):
"""Create the Content-Disposition HTTP header.
This only supports ASCII and UTF-8 encoded strings. For UTF-8 encoded strings a fallback is added for
older browsers.
:param filename: filename to supply
:type filename: str
:param attachment: whether to force a dialog or not
:type attachment: bool
"""
# Start by replacing characters that might cause issues in some browsers
cleaned = force_text(filename if filename else '')
for ch in '/\\";':
cleaned = cleaned.replace(ch, ' ')
cleaned = force_bytes(cleaned)
# Now try to guess the utf-8 and ascii variants of the filename
utf8 = None
ascii = attempt_decode(cleaned, 'ascii')
# If ascii is set, we're dealing with a plain ascii string and no further processing is needed.
if not ascii:
utf8 = attempt_decode(cleaned, 'utf-8')
if utf8:
# So the filename is utf-8 encoded; now try to get a sane ascii version for older browsers
try:
ascii = unicodedata.normalize('NFKD', utf8).encode('ascii', 'ignore')
except UnicodeDecodeError:
pass
# The string's not ascii nor utf-8. We can only hope for the best.
if not ascii:
ascii = cleaned
ascii = force_text(ascii, encoding='ascii')
format_params = {
'serve_type': 'attachment' if attachment else 'inline',
'ascii': ascii
}
if utf8 and ascii:
format_params['utf8'] = urlquote(utf8)
header_format = '{serve_type}; filename="{ascii}"; filename*=UTF-8\'\'{utf8}'
else:
header_format = '{serve_type}; filename="{ascii}"'
return header_format.format(**format_params).encode('ascii')
def attempt_decode(s, encoding):
try:
return s.decode(encoding)
except UnicodeDecodeError:
return None
|
# Copyright 2019 Eficent Business and IT Consulting Services
# Copyright 2017-2018 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields
from odoo.tests.common import Form, SavepointCase
class TestPurchaseStockPickingReturnInvoicing(SavepointCase):
at_install = False
post_install = True
@classmethod
def setUpClass(cls):
"""Add some defaults to let the test run without an accounts chart."""
super(TestPurchaseStockPickingReturnInvoicing, cls).setUpClass()
cls.journal = cls.env["account.journal"].create(
{"name": "Test journal", "type": "purchase", "code": "TEST_J"}
)
cls.account_payable_type = cls.env["account.account.type"].create(
{
"name": "Payable account type",
"type": "payable",
"internal_group": "liability",
}
)
cls.account_expense_type = cls.env["account.account.type"].create(
{
"name": "Expense account type",
"type": "other",
"internal_group": "expense",
}
)
cls.payable_account = cls.env["account.account"].create(
{
"name": "Payable Account",
"code": "PAY",
"user_type_id": cls.account_payable_type.id,
"reconcile": True,
}
)
cls.expense_account = cls.env["account.account"].create(
{
"name": "Expense Account",
"code": "EXP",
"user_type_id": cls.account_expense_type.id,
"reconcile": False,
}
)
cls.partner = cls.env["res.partner"].create(
{"name": "Test partner", "is_company": True}
)
cls.partner.property_account_payable_id = cls.payable_account
cls.product_categ = cls.env["product.category"].create(
{"name": "Test category"}
)
cls.product = cls.env["product.product"].create(
{
"name": "test product",
"categ_id": cls.product_categ.id,
"uom_id": cls.env.ref("uom.product_uom_unit").id,
"uom_po_id": cls.env.ref("uom.product_uom_unit").id,
"default_code": "tpr1",
}
)
cls.product.property_account_expense_id = cls.expense_account
cls.po = cls.env["purchase.order"].create(
{
"partner_id": cls.partner.id,
"order_line": [
(
0,
0,
{
"name": cls.product.name,
"product_id": cls.product.id,
"product_qty": 5.0,
"product_uom": cls.product.uom_id.id,
"price_unit": 10,
"date_planned": fields.Datetime.now(),
},
)
],
}
)
cls.po_line = cls.po.order_line
cls.po.button_confirm()
def check_values(
self,
po_line,
qty_returned,
qty_received,
qty_refunded,
qty_invoiced,
invoice_status,
):
self.assertAlmostEqual(po_line.qty_returned, qty_returned, 2)
self.assertAlmostEqual(po_line.qty_received, qty_received, 2)
self.assertAlmostEqual(po_line.qty_refunded, qty_refunded, 2)
self.assertAlmostEqual(po_line.qty_invoiced, qty_invoiced, 2)
self.assertEqual(po_line.order_id.invoice_status, invoice_status)
def test_initial_state(self):
self.check_values(self.po_line, 0, 0, 0, 0, "no")
def test_purchase_stock_return_1(self):
"""Test a PO with received, invoiced, returned and refunded qty.
Receive and invoice the PO, then do a return of the picking.
Check that the invoicing status of the purchase, and quantities
received and billed are correct throughout the process.
"""
# receive completely
pick = self.po.picking_ids
pick.move_lines.write({"quantity_done": 5})
pick.button_validate()
self.check_values(self.po_line, 0, 5, 0, 0, "to invoice")
# Make invoice
ctx = self.po.action_view_invoice()["context"]
active_model = self.env["account.move"].with_context(ctx)
view_id = "account.view_move_form"
with Form(active_model, view=view_id) as f:
f.partner_id = self.partner
f.purchase_id = self.po
inv_1 = f.save()
self.check_values(self.po_line, 0, 5, 0, 5, "invoiced")
self.assertAlmostEqual(inv_1.amount_untaxed_signed, -50, 2)
# Return some items, after PO was invoiced
return_wizard = self.env["stock.return.picking"].create({"picking_id": pick.id})
return_wizard._onchange_picking_id()
return_wizard.product_return_moves.write({"quantity": 2, "to_refund": True})
return_pick = pick.browse(return_wizard.create_returns()["res_id"])
return_pick.move_lines.write({"quantity_done": 2})
return_pick.button_validate()
self.check_values(self.po_line, 2, 3, 0, 5, "to invoice")
# Make refund
ctx = self.po.action_view_invoice_refund()["context"]
active_model = self.env["account.move"].with_context(ctx)
view_id = "account.view_move_form"
with Form(active_model, view=view_id) as f:
f.partner_id = self.partner
f.purchase_id = self.po
inv_2 = f.save()
self.check_values(self.po_line, 2, 3, 2, 3, "invoiced")
self.assertAlmostEqual(inv_2.amount_untaxed_signed, 20, 2)
action = self.po.action_view_invoice()
self.assertEqual(action["res_id"], inv_1.id)
action2 = self.po.action_view_invoice_refund()
self.assertEqual(action2["res_id"], inv_2.id)
def test_purchase_stock_return_2(self):
"""Test a PO with received and returned qty, and invoiced after.
Receive the PO, then do a partial return of the picking.
Create a new invoice to get the bill for the remaining qty.
Check that the invoicing status of the purchase, and quantities
received and billed are correct throughout the process.
"""
pick = self.po.picking_ids
pick.move_lines.write({"quantity_done": 5})
pick.button_validate()
# Return some items before PO was invoiced
return_wizard = self.env["stock.return.picking"].create({"picking_id": pick.id})
return_wizard._onchange_picking_id()
return_wizard.product_return_moves.write({"quantity": 2, "to_refund": True})
return_pick = pick.browse(return_wizard.create_returns()["res_id"])
return_pick.move_lines.write({"quantity_done": 2})
return_pick.button_validate()
self.check_values(self.po_line, 2, 3, 0, 0, "to invoice")
# Make invoice
ctx = self.po.action_view_invoice()["context"]
active_model = self.env["account.move"].with_context(ctx)
view_id = "account.view_move_form"
with Form(active_model, view=view_id) as f:
f.partner_id = self.partner
f.purchase_id = self.po
inv_1 = f.save()
self.check_values(self.po_line, 2, 3, 0, 3, "invoiced")
self.assertAlmostEqual(inv_1.amount_untaxed_signed, -30, 2)
|
import thermeq3
import datetime
def add_dummy(status):
"""
:param status: is window open?
:return: nothing
"""
# valves = {valve_adr: [valve_pos, valve_temp, valve_curtemp, valve_name]}
# rooms = {id : [room_name, room_address, is_win_open, curr_temp, average valve position]}
# devices = {addr: [type, serial, name, room, OW, OW_time, status, info, temp offset]}
thermeq3.t3.eq3.rooms.update({"99": ["Dummy room", "DeadBeefValve", False, 22.0, 22]})
thermeq3.t3.eq3.devices.update({"DeadBeefWindow": [4, "IHADBW", "Dummy window", 99, 0,
datetime.datetime(2016, 01, 01, 12, 00, 00), 18, 16, 7]})
thermeq3.t3.eq3.devices.update({"DeadBeefValve": [1, "IHADBV", "Dummy valve", 99, 0,
datetime.datetime(2016, 01, 01, 12, 00, 00), 18, 56, 7]})
thermeq3.t3.eq3.valves.update({"DeadBeefValve": [20, 22.0, 22.0, "Dummy valve"]})
# TBI open/closed window
if status:
thermeq3.t3.eq3.devices["DeadBeefWindow"][4] = 2
thermeq3.t3.eq3.devices["DeadBeefWindow"][5] = \
datetime.datetime.now() - \
datetime.timedelta(seconds=((thermeq3.t3.eq3.ignore_time + 10) * 60))
thermeq3.t3.eq3.rooms["99"][2] = True
else:
thermeq3.t3.eq3.devices["DeadBeefWindow"][4] = 0
thermeq3.t3.eq3.rooms["99"][2] = False
def remove_dummy():
del thermeq3.t3.eq3.rooms["99"]
del thermeq3.t3.eq3.valves["DeadBeefValve"]
del thermeq3.t3.eq3.devices["DeadBeefWindow"]
del thermeq3.t3.eq3.devices["DeadBeefValve"]
|
# Copyright (c) 2015, MapR Technologies
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import json
import logging
from sahara import context
from sahara.i18n import _LI
import sahara.plugins.general.exceptions as ex
import sahara.plugins.provisioning as p
from sahara.utils import files as files
_INSTALL_PACKAGES_TIMEOUT = 3600
LOG = logging.getLogger(__name__)
class Service(object):
def __init__(self):
self._name = None
self._ui_name = None
self._node_processes = frozenset()
self._version = None
self._dependencies = {}
self._ui_info = []
self._cluster_defaults = []
self._node_defaults = []
self._validation_rules = []
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
@property
def ui_name(self):
return self._ui_name
@ui_name.setter
def ui_name(self, value):
self._ui_name = value
@property
def version(self):
return self._version
@version.setter
def version(self, value):
self._version = value
@property
def node_processes(self):
return self._node_processes
@node_processes.setter
def node_processes(self, iterable):
def set_service(node_process):
node_process.service = self
return node_process
self._node_processes = frozenset(map(set_service, iterable))
@property
def dependencies(self):
return self._dependencies
@dependencies.setter
def dependencies(self, value):
self._dependencies = value
@property
def ui_info(self):
return self._ui_info
@ui_info.setter
def ui_info(self, iterable):
self._ui_info = iterable
@property
def cluster_defaults(self):
return self._cluster_defaults
@cluster_defaults.setter
def cluster_defaults(self, defaults):
self._cluster_defaults = defaults
@property
def node_defaults(self):
return self._node_defaults
@node_defaults.setter
def node_defaults(self, defaults):
self._node_defaults = defaults
def get_node_processes(self):
return self.node_processes
def get_versions(self):
return self._version
@property
def validation_rules(self):
return self._validation_rules
def install(self, cluster_context, instances):
LOG.info(
_LI('START: Installing %(service)s on cluster=%(cluster)s'),
{'service': self._ui_name, 'cluster': cluster_context.cluster.name}
)
with context.ThreadGroup() as tg:
for instance in instances:
tg.spawn('install-packages-%s' % instance.id,
self._install_packages_on_instance, cluster_context,
instance)
LOG.info(_LI('END: Installing packages on cluster=%s'),
cluster_context.cluster.name)
def _install_packages_on_instance(self, cluster_context, instance):
processes = [p for p in self.get_node_processes() if
p.get_ui_name() in instance.node_group.node_processes]
if processes is not None and len(processes) > 0:
LOG.info(
_LI('START: Installing %(service)s on %(instance)s'),
{'service': self.ui_name, 'instance': instance.management_ip}
)
packages = self._get_packages(processes)
cmd = cluster_context.distro.create_install_cmd(packages)
with instance.remote() as r:
r.execute_command(cmd, run_as_root=True,
timeout=_INSTALL_PACKAGES_TIMEOUT,
raise_when_error=False)
LOG.info(_LI('END: Installing packages on instance=%s'),
instance.management_ip)
def _get_packages(self, node_processes):
result = []
result += self.dependencies
result += [(np.get_package(), self.version) for np in node_processes]
return result
def post_install(self, cluster_context, instances):
pass
def post_start(self, cluster_context, instances):
pass
def configure(self, cluster_context, instances=None):
pass
def update(self, cluster_context, instances=None):
pass
def get_file_path(self, file_name):
template = 'plugins/mapr/services/%(service)s/resources/%(file_name)s'
args = {'service': self.name, 'file_name': file_name}
return template % args
def get_configs(self):
result = []
for d_file in self.cluster_defaults:
data = self._load_config_file(self.get_file_path(d_file))
result += [self._create_config_obj(c, self.ui_name) for c in data]
for d_file in self.node_defaults:
data = self._load_config_file(self.get_file_path(d_file))
result += [self._create_config_obj(c, self.ui_name, scope='node')
for c in data]
return result
def get_configs_dict(self):
result = dict()
for conf_obj in self.get_configs():
result.update({conf_obj.name: conf_obj.default_value})
return {self.ui_name: result}
def _load_config_file(self, file_path=None):
return json.loads(files.get_file_text(file_path))
def get_config_files(self, cluster_context, configs, instance=None):
return []
def _create_config_obj(self, item, target='general', scope='cluster',
high_priority=False):
def _prepare_value(value):
if isinstance(value, str):
return value.strip().lower()
return value
conf_name = _prepare_value(item.get('name', None))
conf_value = _prepare_value(item.get('value', None))
if not conf_name:
raise ex.HadoopProvisionError(_LI("Config missing 'name'"))
if conf_value is None:
raise ValueError(
"Config '%s' missing 'value'" % conf_name)
if high_priority or item.get('priority', 2) == 1:
priority = 1
else:
priority = 2
return p.Config(
name=conf_name,
applicable_target=target,
scope=scope,
config_type=item.get('config_type', "string"),
config_values=item.get('config_values', None),
default_value=conf_value,
is_optional=item.get('is_optional', True),
description=item.get('description', None),
priority=priority)
def get_version_config(self, versions):
return p.Config(
name='%s Version' % self._ui_name,
applicable_target=self.ui_name,
scope='cluster',
config_type='dropdown',
config_values=[(v, v) for v in sorted(versions, reverse=True)],
is_optional=False,
description=_LI('Specify the version of the service'),
priority=1)
def __eq__(self, other):
if isinstance(other, self.__class__):
version_eq = self.version == other.version
name_eq = self.name == other.name
ui_name_eq = self.ui_name == other.ui_name
return version_eq and name_eq and ui_name_eq
return NotImplemented
def __repr__(self):
return '<Service %s>' % self.ui_name
def restart(self, instances):
for node_process in self.node_processes:
node_process.restart(instances)
def home_dir(self, cluster_context):
args = {
'mapr_home': cluster_context.mapr_home,
'name': self.name,
'version': self.version,
}
return '%(mapr_home)s/%(name)s/%(name)s-%(version)s' % args
class Single(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(Single, cls).__call__(*args, **kwargs)
return cls._instances[cls]
|
#!/usr/bin/env python
import sys, os
script_path = os.path.dirname(os.path.realpath(__file__))
modules_path = os.path.normcase("../../")
modules_directory = os.path.join(script_path, modules_path)
sys.path.append(modules_directory)
from PyQt4 import QtGui, QtCore
from omelette.fromage.ui import Ui_MainWindow
#from omelette.fromage.fromage_editor import FromageEditor
from omelette.fromage.qscintilla import QSci
from omelette.fromage.actions import Actions
from omelette.fromage.scalable_view import ScalableView
from omelette.fromage.layouter import *
class QFromage(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
frect = self.frameGeometry()
frect.moveCenter(QtGui.QDesktopWidget().availableGeometry().center())
self.move(frect.topLeft())
self.setupUi(self)
self.hlayout = QtGui.QHBoxLayout(self.centralwidget)
self.vlayout = QtGui.QVBoxLayout(self.dockContents)
self.splitter = QtGui.QSplitter(self.centralwidget)
self.splitter.setOrientation(QtCore.Qt.Horizontal)
self.qsci = QSci(self.splitter)
#self.qsci = FromageEditor(self.splitter)
self.scene = QtGui.QGraphicsScene(self.splitter)
self.scalable_view = ScalableView(self.splitter)
self.scalable_view.setScene(self.scene)
self.scene.setSceneRect(QtCore.QRectF(0, 0, 500, 500))
self.splitter.setSizes([1,1])
self.msg_view = QtGui.QTableWidget()
self.msg_view.setColumnCount(3)
self.msg_view.setHorizontalHeaderLabels(["Marker", "Line number", "Message"])
self.msg_view.horizontalHeader().setStretchLastSection(True)
self.msg_view.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.msg_view.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
for i in range(3):
self.msg_view.horizontalHeaderItem(i).setTextAlignment(0x0001)
self.vlayout.addWidget(self.msg_view)
self.hlayout.addWidget(self.splitter)
layouts_names = LayoutFactory.layouts()
for name in layouts_names:
self.layout = QtGui.QAction(self)
self.layout.setObjectName(QtCore.QString.fromUtf8(name))
self.layout.setCheckable(True)
self.layout.setText(name)
self.menuLayout.addAction(self.layout)
self.actions = Actions(self)
QtCore.QObject.connect(self.actionGenerate, QtCore.SIGNAL("triggered()"), self.actions.generate)
QtCore.QObject.connect(self.actionNew, QtCore.SIGNAL("triggered()"), self.actions.new_file)
QtCore.QObject.connect(self.actionOpen, QtCore.SIGNAL("triggered()"), self.actions.open_file)
QtCore.QObject.connect(self.actionSave, QtCore.SIGNAL("triggered()"), self.actions.save_file)
QtCore.QObject.connect(self.actionSaveAs, QtCore.SIGNAL("triggered()"), self.actions.save_file_as)
QtCore.QObject.connect(self.actionCut, QtCore.SIGNAL("triggered()"), self.actions.cut)
QtCore.QObject.connect(self.actionCopy, QtCore.SIGNAL("triggered()"), self.actions.copy)
QtCore.QObject.connect(self.actionPaste, QtCore.SIGNAL("triggered()"), self.actions.paste)
QtCore.QObject.connect(self.actionUndo, QtCore.SIGNAL("triggered()"), self.actions.undo)
QtCore.QObject.connect(self.actionRedo, QtCore.SIGNAL("triggered()"), self.actions.redo)
QtCore.QObject.connect(self.qsci, QtCore.SIGNAL("textChanged()"), self.actions.enable_save)
QtCore.QObject.connect(self.actionExport, QtCore.SIGNAL("triggered()"), self.actions.export)
QtCore.QObject.connect(self.menuLayout, QtCore.SIGNAL("triggered(QAction*)"), self.actions.get_layout_name)
QtCore.QObject.connect(self.menuLayout, QtCore.SIGNAL("triggered(QAction*)"), self.actions.check_layout_item)
QtCore.QObject.connect(self.msg_view, QtCore.SIGNAL("cellDoubleClicked(int,int)"), self.actions.jump_to_line)
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
form = QFromage()
if len(sys.argv) == 2:
with open(sys.argv[1], 'r') as f:
for line in f:
form.qsci.append(line)
form.actions.generate()
form.show()
else:
form.show()
sys.exit(app.exec_())
|
# -*- conding=utf-8 -*-
"""
train module
"""
import mxnet as mx
import numpy as np
import json
import config
import logging
import time
import collections
from sym import vgg16_fc7, caption_module
from data_provider import caption_dataIter, init_cnn
from mxnet.model import save_checkpoint
import argparse
logging.basicConfig(level=logging.INFO)
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--epoches', default=20, type=int, help="epoches in training-stage", dest='epoches')
parser.add_argument('--batch_size', default=50, type=int, help="batch_size in training-stage", dest='batch_size')
parser.add_argument('--num_hidden', default=256, type=int, help="the number of hidden unit", dest='num_hidden')
parser.add_argument('--lr', default=0.01, type=float, help="learning rate in training-stage", dest='lr')
parser.add_argument('--freq_val', default=5, type=int, help="frequence of validation", dest='freq_val')
parser.add_argument('--num_embed', default=256, type=int, help="the number of embedding dimension", dest='num_embed')
parser.add_argument('--num_lstm_layer', default=256, type=int, help="the number of hidden_unit", dest='num_lstm_layer')
parser.add_argument('--gpu', default=None, type=str, help="wether run on gpu device", dest='gpu')
parser.add_argument('--prefix', default='./checkpoint/train', type=str, help="prefix of save checkpoint", dest='prefix')
parser.add_argument('--period', default=5, type=int, help="times to save checkpoint in training-stage", dest='period')
return parser.parse_args()
class callbacks:
def __init__(self, nbatch, eval_metric, epoch):
self.nbatch = nbatch
self.eval_metric = eval_metric
self.epoch = epoch
def main(args):
learning_rate = args.lr
epoches = args.epoches
batch_size = args.batch_size
num_hidden = args.num_hidden
num_embed = args.num_embed
num_lstm_layer = args.num_lstm_layer
freq_val = args.freq_val
val_flag = True if args.freq_val > 0 else False
ctx = mx.cpu(0) if args.gpu is None else mx.gpu(int(args.gpu))
prefix = args.prefix
period = args.period
with open(config.text_root, 'r') as f:
captions = json.load(f)
buckets = [10, 20, 30]
# buckets = None
train_data = caption_dataIter(
captions=captions, batch_size=batch_size, mode='train')
val_data = caption_dataIter(
captions=captions, batch_size=batch_size, mode='val')
##########################################################################
########################### custom train process #########################
##########################################################################
cnn_shapes = {
'image_data': (batch_size, 3, 224, 224)
}
cnn_sym = vgg16_fc7('image_data')
cnn_exec = cnn_sym.simple_bind(ctx=ctx, is_train=False, **cnn_shapes)
lstm = caption_module(num_lstm_layer=num_lstm_layer, seq_len=train_data.sent_length+2,
vocab_size=train_data.vocab_size, num_hidden=num_hidden, num_embed=num_embed, batch_size=batch_size)
lstm_shapes = {
'image_feature': (batch_size, 4096),
'word_data': (batch_size, train_data.sent_length+2),
'softmax_label': (batch_size, train_data.sent_length+2)
}
lstm_exec = lstm.simple_bind(
ctx=ctx, is_train=True, **lstm_shapes)
# init params
pretrain = mx.nd.load(config.vgg_pretrain)
init_cnn(cnn_exec, pretrain)
# init optimazer
optimazer = mx.optimizer.create('adam')
optimazer.lr = learning_rate
updater = mx.optimizer.get_updater(optimazer)
# init metric
perplexity = mx.metric.Perplexity(ignore_label=-1)
perplexity.reset()
# callback
params = callbacks(nbatch=0, eval_metric=perplexity, epoch=0)
speedometer = mx.callback.Speedometer(batch_size=batch_size, frequent=20)
for epoch in range(epoches):
for i, batch in enumerate(train_data):
# cnn forward, get image_feature
cnn_exec.arg_dict['image_data'] = batch.data[0]
cnn_exec.forward()
image_feature = cnn_exec.outputs[0]
# lstm forward
lstm_exec.arg_dict['image_feature'] = image_feature
lstm_exec.arg_dict['word_data'] = batch.data[1]
lstm_exec.arg_dict['softmax_label'] = batch.label
lstm_exec.forward(is_train=True)
print batch.label
params.eval_metric.update(labels=batch.label,
preds=lstm_exec.outputs)
lstm_exec.backward()
params.epoch = epoch
params.nbatch += 1
speedometer(params)
for j, name in enumerate(lstm.list_arguments()):
if name not in lstm_shapes.keys():
updater(j, lstm_exec.grad_dict[
name], lstm_exec.arg_dict[name])
train_data.reset()
params.nbatch = 0
if val_flag and epoch % freq_val == 0:
for i, batch in enumerate(val_data):
# cnn forward, get image_feature
cnn_exec.arg_dict['image_data'] = batch.data[0]
cnn_exec.forward()
image_feature = cnn_exec.outputs[0]
# lstm forward
lstm_exec.arg_dict['image_feature'] = image_feature
lstm_exec.arg_dict['word_data'] = batch.data[1]
lstm_exec.arg_dict['softmax_label'] = batch.label
lstm_exec.forward(is_train=False)
params.eval_metric.update(labels=batch.label,
preds=lstm_exec.outputs)
params.epoch = epoch
params.nbatch += 1
speedometer(params)
params.nbatch = 0
val_data.reset()
if period:
save_checkpoint(prefix=prefix, epoch=epoch, symbol=lstm,
arg_params=lstm_exec.arg_dict,
aux_params=lstm_exec.aux_dict)
if __name__ == '__main__':
args = parse_args()
main(args)
|
# -*- encoding: utf-8 -*-
import datetime
import os
import string
from src.convertors.base.bqt.currentbooksettings import CurrentBookSettings
from src.utils import commonscript
from src.utils.logger import log
from src.convertors.base.bqt.bqtdata import *
from src.utils.common import getFileNameInProperCase
class IniReader():
class CCurrentBookSettings(CurrentBookSettings):
pass
def __init__(self, ini_path):
self.input_filename = ini_path
self.ini_file = file(self.input_filename, 'r')
self.__set_default_values()
def __set_default_values(self):
self.Books = []
self.CurrentBookSettings = self.CCurrentBookSettings()
self.IniDesiredFontName = ""
self.init_values()
def init_data(self, dict_data):
self.ini_type = dict_data.get("IniType")
self.module_type = dict_data.get("ModuleType")
# self.INIEncoding = dict_data.get("INIEncoding")
self.ini_encoding = commonscript.getEncoding(self.input_filename)
self.module_directory = dict_data.get("ModuleDirectory")
def init_values(self):
self.introduction_exist = False
self.strongs_exist = False
self.ini_chapter_zero = 'N'
self.ini_apocrypha = 'N'
self.ini_strong_numbers = 'N'
self.ini_old_testament = ""
self.ini_new_testament = ""
self.ini_copyright = ""
self.ini_categories = ""
self.ini_greek = ""
self.ini_bible = "Y"
self.ini_desired_fontcharset = ""
self.ini_htmlfilter = ""
self.ini_alphabet = ""
self.ini_strongs_dDirectory = ""
self.ini_default_encoding = "utf-8"
self.ini_language = ""
self.ini_desired_fontpath = ""
self.ini_bookqt = 0
self.ini_bookchaptersign = ""
self.ini_bookversesign = ""
self.ini_developer = ""
self.ini_devcontact = ""
self.ini_date = datetime.date.today()
self.ini_version = "1.0"
self.ini_description = ""
self.ini_dict = {}
# разбор bibleqt.ini
def parse_ini(self):
general_settings_parsed = False
self.init_values()
for line in self.ini_file:
# перекодируем строки в UTF-8
line = line.decode(self.ini_encoding).encode('utf_8').strip()
# Line = Line.decode('utf_8').strip()
# обработка основных параметров модуля
if not general_settings_parsed:
general_settings_parsed = self.__parse_general_settings(line)
else:
# обработка параметров конкретной книги модуля
self.__parse_book_settings(line)
def __generate_ini_dict(self):
ini_dict = {}
ini_dict['DesiredFontName'] = self.IniDesiredFontName
ini_dict['BibleName'] = self.HeadBibleName
ini_dict['BibleShortName'] = self.HeadBibleShortName
ini_dict['ChapterZero'] = self.ini_chapter_zero
ini_dict['Apocrypha'] = self.ini_apocrypha
ini_dict['StrongNumbers'] = self.ini_strong_numbers
ini_dict['OldTestament'] = self.ini_old_testament
ini_dict['NewTestament'] = self.ini_new_testament
ini_dict['Copyright'] = self.ini_copyright
ini_dict['Categories'] = self.ini_categories
ini_dict['Greek'] = self.ini_greek
ini_dict['Bible'] = self.ini_bible
ini_dict['DesiredFontCharset'] = self.ini_desired_fontcharset
ini_dict['HTMLFilter'] = self.ini_htmlfilter
ini_dict['Alphabet'] = self.ini_alphabet
ini_dict['StrongsDirectory'] = self.ini_strongs_dDirectory
ini_dict['DefaultEncoding'] = self.ini_default_encoding
ini_dict['Language'] = self.ini_language
ini_dict['DesiredFontPath'] = self.ini_desired_fontpath
ini_dict['BookQt'] = self.ini_bookqt
ini_dict['ChapterSign'] = self.ini_bookchaptersign
ini_dict['VerseSign'] = self.ini_bookversesign
ini_dict['Type'] = self.ini_type
ini_dict['Developer'] = self.ini_developer
ini_dict['DevContact'] = self.ini_devcontact
ini_dict['Date'] = self.ini_date
ini_dict['Version'] = self.ini_version
ini_dict['Description'] = self.ini_description
ini_dict['Books'] = self.Books
return ini_dict
# self.IniDict[''] = self.Ini
def __parse_general_settings(self, line):
# название модуля и короткое название
if line.startswith('BibleName'):
self.HeadBibleName = commonscript.getValue(line)
return False
# название модуля и короткое название
if line.startswith('Bible '):
self.ini_bible = commonscript.getValue(line)
return False
if line.startswith('BibleShortName'):
self.HeadBibleShortName = commonscript.getValue(line)
self.__check_module_name(self.HeadBibleShortName)
if self.module_type == 'Apocrypha':
self.HeadBibleShortName += '-Apocrypha'
return False
# начинается ли в модуле исчисление глав с нуля
if line.startswith('ChapterZero'):
self.ini_chapter_zero = commonscript.getValue(line)
if self.ini_chapter_zero == 'Y':
self.introduction_exist = True
self.OsisWriter.RemakeVersificationProblems()
return False
# считываем признак начала главы в HTML файле
if line.startswith('ChapterSign'):
self.ini_bookchaptersign = commonscript.getValue(line, "ChapterSign")
return False
# считываем копирайт
if line.startswith('Copyright'):
self.ini_copyright = commonscript.getValue(line)
return False
if line.startswith('Alphabet'):
self.ini_alphabet = commonscript.getValue(line)
return False
if line.startswith('HTMLFilter'):
self.ini_htmlfilter = commonscript.getValue(line, "HTMLFilter")
return False
if line.startswith('DesiredFontCharset'):
self.ini_desired_fontcharset = commonscript.getValue(line)
return False
# считываем грееческий
if line.startswith('Greek'):
self.ini_greek = commonscript.getValue(line)
return False
# считываем категории
if line.startswith('Categories'):
self.ini_categories = commonscript.getValue(line)
return False
if line.startswith('StrongsDirectory'):
self.ini_strongs_dDirectory = commonscript.getValue(line)
return False
# считываем признак начала стиха
if line.startswith('VerseSign'):
self.ini_bookversesign = commonscript.getValue(line, "VerseSign")
return False
if line.startswith('DesiredFontName'):
self.IniDesiredFontName = commonscript.getValue(line)
return False
if line.startswith('OldTestament'):
self.ini_old_testament = commonscript.getValue(line)
return False
if line.startswith('NewTestament'):
self.ini_new_testament = commonscript.getValue(line)
return False
# выводим сообщение о том, что программа не обрабатывает апокрифы
if line.startswith('Apocrypha'):
self.ini_apocrypha = commonscript.getValue(line)
if self.ini_apocrypha == 'Y' and \
not self.module_type == 'Apocrypha':
log("""
Скрипт не обрабатывает апокрифы, в связи с тем, что на
данный момент библиотека Sword не поддерживает апокрифы
в библейских модулях. Если вам все же нужны апокрифы, то
запустите скрипт с параметром "--moduletype Apocrypha",
чтобы получить модуль, содержащий только апокрифы в формате
обычной книги.
""")
return False
# определяем наличие в модуле номеров Стронга
if line.startswith('StrongNumbers'):
self.ini_strong_numbers = commonscript.getValue(line)
if self.ini_strong_numbers == 'Y' and self.module_type not in JustBooks:
self.strongs_exist = True
return False
# считываем количество книг
if line.startswith('BookQty'):
self.ini_bookqt = commonscript.getValue(line)
self.IniBookCount = 0
return True
# мои опции
if line.startswith('Description'):
self.ini_description = commonscript.getValue(line)
return False
if line.startswith('Developer'):
self.IniDevelop = commonscript.getValue(line)
return False
if line.startswith('Date'):
self.ini_date = commonscript.getValue(line)
return False
if line.startswith('Version'):
self.ini_version = commonscript.getValue(line)
return False
if line.startswith('Type'):
self.ini_type = commonscript.getValue(line)
return False
def __parse_book_settings(self, line):
# считываем имя файла, относительно текущей директории
if line.startswith('PathName'):
self.CurrentBookSettings.PathName = "book_" + str(self.IniBookCount + 1) + \
'.html'
self.CurrentBookSettings.BookPathToFile = self.module_directory + commonscript.getValue(line)
return
# ищем соответвие длинного названия книги и короткого
if line.startswith('ShortName') and self.module_type != 'Book':
self.CurrentBookSettings.ShortName = commonscript.getValue(line)
if not self.CurrentBookSettings.ShortName:
self.CurrentBookSettings.ShortName = "Empty ShortName"
if not self.CurrentBookSettings.FullName:
self.CurrentBookSettings.FullName = "Empty FullName"
return
# TODO переписать этот блок по нормальному
for Pair in TableBooks:
if Pair[0] in line:
# self.CurrentBookSettings.FullName = Pair[1]
# self.CurrentBookSettings.Testament = Pair[2]
if Pair[2] == 3 and \
not self.module_type == 'Apocrypha':
log('ПРЕДУПРЕЖДЕНИЕ: ', self.CurrentBookSettings.FullName, ' - апокрифическая книга.')
# self.CurrentBookSettings.FullName = ''
elif Pair[2] != 3 and self.module_type == 'Apocrypha':
log('ПРЕДУПРЕЖДЕНИЕ: ' + \
self.CurrentBookSettings.FullName + \
' - каноническая книга.')
# self.CurrentBookSettings.FullName = ''
break
if Pair == TableBooks[len(TableBooks) - 1]:
# self.CurrentBookSettings.FullName = Pair[1]
# self.CurrentBookSettings.FullName = commonscript.getValue(Line)
log('Ошибка, не найдено название книги "' + self.CurrentBookSettings.FullName + '"')
# сохраняем название книги
if line.startswith('FullName') and (self.module_type != 'Dictionary'):
self.CurrentBookSettings.FullName = commonscript.getValue(line)
return False
# переходим к чтению файла книги
if line.startswith('ChapterQty') and self.CurrentBookSettings.FullName != '':
if os.path.exists(getFileNameInProperCase(self.CurrentBookSettings.BookPathToFile)):
self.CurrentBookSettings.BookPathToFile = getFileNameInProperCase(
self.CurrentBookSettings.BookPathToFile)
BookFile = file(getFileNameInProperCase(self.CurrentBookSettings.BookPathToFile), 'r')
self.CurrentBookSettings.ChapterQty = commonscript.getValue(line)
# печатаем книгу в ini файл
log('Обрабатываю файл ' + self.CurrentBookSettings.BookPathToFile)
self.CurrentBookSettings.Encoding = commonscript.getEncoding(self.CurrentBookSettings.BookPathToFile)
self.CurrentBookSettings.ChapterSign = self.ini_bookchaptersign
self.Books.append(self.CurrentBookSettings)
self.CurrentBookSettings = self.CCurrentBookSettings()
self.IniBookCount += 1
BookFile.close()
else:
print "Not found file " + getFileNameInProperCase(self.CurrentBookSettings.BookPathToFile)
def __check_module_name(self, name):
for i in xrange(0, len(name)):
if not name[i] in string.printable:
log('ПРЕДУПРЕЖДЕНИЕ: имя модуля содержит нелатинские\n'
'символы. Итоговый модуль Sword не будет работать\n'
'в некоторых фронтендах. Например BibleTime.\n')
return
def get_ini_info(self):
return self.__generate_ini_dict()
|
"""Class to manage the entities for a single platform."""
import asyncio
from contextvars import ContextVar
from typing import Optional
from homeassistant.const import DEVICE_DEFAULT_NAME
from homeassistant.core import callback, split_entity_id, valid_entity_id
from homeassistant.exceptions import HomeAssistantError, PlatformNotReady
from homeassistant.util.async_ import run_callback_threadsafe
from .entity_registry import DISABLED_INTEGRATION
from .event import async_call_later, async_track_time_interval
# mypy: allow-untyped-defs, no-check-untyped-defs
SLOW_SETUP_WARNING = 10
SLOW_SETUP_MAX_WAIT = 60
PLATFORM_NOT_READY_RETRIES = 10
class EntityPlatform:
"""Manage the entities for a single platform."""
def __init__(
self,
*,
hass,
logger,
domain,
platform_name,
platform,
scan_interval,
entity_namespace,
async_entities_added_callback,
):
"""Initialize the entity platform.
hass: HomeAssistant
logger: Logger
domain: str
platform_name: str
scan_interval: timedelta
entity_namespace: str
async_entities_added_callback: @callback method
"""
self.hass = hass
self.logger = logger
self.domain = domain
self.platform_name = platform_name
self.platform = platform
self.scan_interval = scan_interval
self.entity_namespace = entity_namespace
self.async_entities_added_callback = async_entities_added_callback
self.config_entry = None
self.entities = {}
self._tasks = []
# Method to cancel the state change listener
self._async_unsub_polling = None
# Method to cancel the retry of setup
self._async_cancel_retry_setup = None
self._process_updates = None
# Platform is None for the EntityComponent "catch-all" EntityPlatform
# which powers entity_component.add_entities
if platform is None:
self.parallel_updates = None
self.parallel_updates_semaphore = None
return
self.parallel_updates = getattr(platform, "PARALLEL_UPDATES", None)
# semaphore will be created on demand
self.parallel_updates_semaphore = None
def _get_parallel_updates_semaphore(self):
"""Get or create a semaphore for parallel updates."""
if self.parallel_updates_semaphore is None:
self.parallel_updates_semaphore = asyncio.Semaphore(
self.parallel_updates if self.parallel_updates else 1,
loop=self.hass.loop,
)
return self.parallel_updates_semaphore
async def async_setup(self, platform_config, discovery_info=None):
"""Set up the platform from a config file."""
platform = self.platform
hass = self.hass
@callback
def async_create_setup_task():
"""Get task to set up platform."""
if getattr(platform, "async_setup_platform", None):
return platform.async_setup_platform(
hass,
platform_config,
self._async_schedule_add_entities,
discovery_info,
)
# This should not be replaced with hass.async_add_job because
# we don't want to track this task in case it blocks startup.
return hass.loop.run_in_executor(
None,
platform.setup_platform,
hass,
platform_config,
self._schedule_add_entities,
discovery_info,
)
await self._async_setup_platform(async_create_setup_task)
async def async_setup_entry(self, config_entry):
"""Set up the platform from a config entry."""
# Store it so that we can save config entry ID in entity registry
self.config_entry = config_entry
platform = self.platform
@callback
def async_create_setup_task():
"""Get task to set up platform."""
return platform.async_setup_entry(
self.hass, config_entry, self._async_schedule_add_entities
)
return await self._async_setup_platform(async_create_setup_task)
async def _async_setup_platform(self, async_create_setup_task, tries=0):
"""Set up a platform via config file or config entry.
async_create_setup_task creates a coroutine that sets up platform.
"""
current_platform.set(self)
logger = self.logger
hass = self.hass
full_name = f"{self.domain}.{self.platform_name}"
logger.info("Setting up %s", full_name)
warn_task = hass.loop.call_later(
SLOW_SETUP_WARNING,
logger.warning,
"Setup of platform %s is taking over %s seconds.",
self.platform_name,
SLOW_SETUP_WARNING,
)
try:
task = async_create_setup_task()
await asyncio.wait_for(asyncio.shield(task), SLOW_SETUP_MAX_WAIT)
# Block till all entities are done
if self._tasks:
pending = [task for task in self._tasks if not task.done()]
self._tasks.clear()
if pending:
await asyncio.wait(pending)
hass.config.components.add(full_name)
return True
except PlatformNotReady:
tries += 1
wait_time = min(tries, 6) * 30
logger.warning(
"Platform %s not ready yet. Retrying in %d seconds.",
self.platform_name,
wait_time,
)
async def setup_again(now):
"""Run setup again."""
self._async_cancel_retry_setup = None
await self._async_setup_platform(async_create_setup_task, tries)
self._async_cancel_retry_setup = async_call_later(
hass, wait_time, setup_again
)
return False
except asyncio.TimeoutError:
logger.error(
"Setup of platform %s is taking longer than %s seconds."
" Startup will proceed without waiting any longer.",
self.platform_name,
SLOW_SETUP_MAX_WAIT,
)
return False
except Exception: # pylint: disable=broad-except
logger.exception("Error while setting up platform %s", self.platform_name)
return False
finally:
warn_task.cancel()
def _schedule_add_entities(self, new_entities, update_before_add=False):
"""Schedule adding entities for a single platform, synchronously."""
run_callback_threadsafe(
self.hass.loop,
self._async_schedule_add_entities,
list(new_entities),
update_before_add,
).result()
@callback
def _async_schedule_add_entities(self, new_entities, update_before_add=False):
"""Schedule adding entities for a single platform async."""
self._tasks.append(
self.hass.async_add_job(
self.async_add_entities(
new_entities, update_before_add=update_before_add
)
)
)
def add_entities(self, new_entities, update_before_add=False):
"""Add entities for a single platform."""
# That avoid deadlocks
if update_before_add:
self.logger.warning(
"Call 'add_entities' with update_before_add=True "
"only inside tests or you can run into a deadlock!"
)
asyncio.run_coroutine_threadsafe(
self.async_add_entities(list(new_entities), update_before_add),
self.hass.loop,
).result()
async def async_add_entities(self, new_entities, update_before_add=False):
"""Add entities for a single platform async.
This method must be run in the event loop.
"""
# handle empty list from component/platform
if not new_entities:
return
hass = self.hass
device_registry = await hass.helpers.device_registry.async_get_registry()
entity_registry = await hass.helpers.entity_registry.async_get_registry()
tasks = [
self._async_add_entity(
entity, update_before_add, entity_registry, device_registry
)
for entity in new_entities
]
# No entities for processing
if not tasks:
return
await asyncio.wait(tasks)
self.async_entities_added_callback()
if self._async_unsub_polling is not None or not any(
entity.should_poll for entity in self.entities.values()
):
return
self._async_unsub_polling = async_track_time_interval(
self.hass, self._update_entity_states, self.scan_interval
)
async def _async_add_entity(
self, entity, update_before_add, entity_registry, device_registry
):
"""Add an entity to the platform."""
if entity is None:
raise ValueError("Entity cannot be None")
entity.hass = self.hass
entity.platform = self
# Async entity
# PARALLEL_UPDATES == None: entity.parallel_updates = None
# PARALLEL_UPDATES == 0: entity.parallel_updates = None
# PARALLEL_UPDATES > 0: entity.parallel_updates = Semaphore(p)
# Sync entity
# PARALLEL_UPDATES == None: entity.parallel_updates = Semaphore(1)
# PARALLEL_UPDATES == 0: entity.parallel_updates = None
# PARALLEL_UPDATES > 0: entity.parallel_updates = Semaphore(p)
if hasattr(entity, "async_update") and not self.parallel_updates:
entity.parallel_updates = None
elif not hasattr(entity, "async_update") and self.parallel_updates == 0:
entity.parallel_updates = None
else:
entity.parallel_updates = self._get_parallel_updates_semaphore()
# Update properties before we generate the entity_id
if update_before_add:
try:
await entity.async_device_update(warning=False)
except Exception: # pylint: disable=broad-except
self.logger.exception("%s: Error on device update!", self.platform_name)
return
suggested_object_id = None
# Get entity_id from unique ID registration
if entity.unique_id is not None:
if entity.entity_id is not None:
suggested_object_id = split_entity_id(entity.entity_id)[1]
else:
suggested_object_id = entity.name
if self.entity_namespace is not None:
suggested_object_id = "{} {}".format(
self.entity_namespace, suggested_object_id
)
if self.config_entry is not None:
config_entry_id = self.config_entry.entry_id
else:
config_entry_id = None
device_info = entity.device_info
device_id = None
if config_entry_id is not None and device_info is not None:
processed_dev_info = {"config_entry_id": config_entry_id}
for key in (
"connections",
"identifiers",
"manufacturer",
"model",
"name",
"sw_version",
"via_device",
):
if key in device_info:
processed_dev_info[key] = device_info[key]
device = device_registry.async_get_or_create(**processed_dev_info)
if device:
device_id = device.id
disabled_by: Optional[str] = None
if not entity.entity_registry_enabled_default:
disabled_by = DISABLED_INTEGRATION
entry = entity_registry.async_get_or_create(
self.domain,
self.platform_name,
entity.unique_id,
suggested_object_id=suggested_object_id,
config_entry=self.config_entry,
device_id=device_id,
known_object_ids=self.entities.keys(),
disabled_by=disabled_by,
)
entity.registry_entry = entry
entity.entity_id = entry.entity_id
if entry.disabled:
self.logger.info(
"Not adding entity %s because it's disabled",
entry.name
or entity.name
or f'"{self.platform_name} {entity.unique_id}"',
)
return
# We won't generate an entity ID if the platform has already set one
# We will however make sure that platform cannot pick a registered ID
elif entity.entity_id is not None and entity_registry.async_is_registered(
entity.entity_id
):
# If entity already registered, convert entity id to suggestion
suggested_object_id = split_entity_id(entity.entity_id)[1]
entity.entity_id = None
# Generate entity ID
if entity.entity_id is None:
suggested_object_id = (
suggested_object_id or entity.name or DEVICE_DEFAULT_NAME
)
if self.entity_namespace is not None:
suggested_object_id = "{} {}".format(
self.entity_namespace, suggested_object_id
)
entity.entity_id = entity_registry.async_generate_entity_id(
self.domain, suggested_object_id, self.entities.keys()
)
# Make sure it is valid in case an entity set the value themselves
if not valid_entity_id(entity.entity_id):
raise HomeAssistantError(f"Invalid entity id: {entity.entity_id}")
if (
entity.entity_id in self.entities
or entity.entity_id in self.hass.states.async_entity_ids(self.domain)
):
msg = f"Entity id already exists: {entity.entity_id}"
if entity.unique_id is not None:
msg += ". Platform {} does not generate unique IDs".format(
self.platform_name
)
raise HomeAssistantError(msg)
entity_id = entity.entity_id
self.entities[entity_id] = entity
entity.async_on_remove(lambda: self.entities.pop(entity_id))
await entity.async_internal_added_to_hass()
await entity.async_added_to_hass()
await entity.async_update_ha_state()
async def async_reset(self):
"""Remove all entities and reset data.
This method must be run in the event loop.
"""
if self._async_cancel_retry_setup is not None:
self._async_cancel_retry_setup()
self._async_cancel_retry_setup = None
if not self.entities:
return
tasks = [self.async_remove_entity(entity_id) for entity_id in self.entities]
await asyncio.wait(tasks)
if self._async_unsub_polling is not None:
self._async_unsub_polling()
self._async_unsub_polling = None
async def async_remove_entity(self, entity_id):
"""Remove entity id from platform."""
await self.entities[entity_id].async_remove()
# Clean up polling job if no longer needed
if self._async_unsub_polling is not None and not any(
entity.should_poll for entity in self.entities.values()
):
self._async_unsub_polling()
self._async_unsub_polling = None
async def _update_entity_states(self, now):
"""Update the states of all the polling entities.
To protect from flooding the executor, we will update async entities
in parallel and other entities sequential.
This method must be run in the event loop.
"""
if self._process_updates is None:
self._process_updates = asyncio.Lock()
if self._process_updates.locked():
self.logger.warning(
"Updating %s %s took longer than the scheduled update " "interval %s",
self.platform_name,
self.domain,
self.scan_interval,
)
return
async with self._process_updates:
tasks = []
for entity in self.entities.values():
if not entity.should_poll:
continue
tasks.append(entity.async_update_ha_state(True))
if tasks:
await asyncio.wait(tasks)
current_platform: ContextVar[Optional[EntityPlatform]] = ContextVar(
"current_platform", default=None
)
|
# -*- coding: utf-8 -*-
import operator
import pytest
import numpy as np
from pandas.compat import range
import pandas as pd
import pandas.util.testing as tm
from pandas.tests.frame.common import _check_mixed_float, _check_mixed_int
# -------------------------------------------------------------------
# Comparisons
class TestFrameComparisons(object):
def test_flex_comparison_nat(self):
# GH 15697, GH 22163 df.eq(pd.NaT) should behave like df == pd.NaT,
# and _definitely_ not be NaN
df = pd.DataFrame([pd.NaT])
result = df == pd.NaT
# result.iloc[0, 0] is a np.bool_ object
assert result.iloc[0, 0].item() is False
result = df.eq(pd.NaT)
assert result.iloc[0, 0].item() is False
result = df != pd.NaT
assert result.iloc[0, 0].item() is True
result = df.ne(pd.NaT)
assert result.iloc[0, 0].item() is True
def test_mixed_comparison(self):
# GH 13128, GH 22163 != datetime64 vs non-dt64 should be False,
# not raise TypeError
# (this appears to be fixed before #22163, not sure when)
df = pd.DataFrame([['1989-08-01', 1], ['1989-08-01', 2]])
other = pd.DataFrame([['a', 'b'], ['c', 'd']])
result = df == other
assert not result.any().any()
result = df != other
assert result.all().all()
def test_df_boolean_comparison_error(self):
# GH#4576, GH#22880
# comparing DataFrame against list/tuple with len(obj) matching
# len(df.columns) is supported as of GH#22800
df = pd.DataFrame(np.arange(6).reshape((3, 2)))
expected = pd.DataFrame([[False, False],
[True, False],
[False, False]])
result = df == (2, 2)
tm.assert_frame_equal(result, expected)
result = df == [2, 2]
tm.assert_frame_equal(result, expected)
def test_df_float_none_comparison(self):
df = pd.DataFrame(np.random.randn(8, 3), index=range(8),
columns=['A', 'B', 'C'])
result = df.__eq__(None)
assert not result.any().any()
def test_df_string_comparison(self):
df = pd.DataFrame([{"a": 1, "b": "foo"}, {"a": 2, "b": "bar"}])
mask_a = df.a > 1
tm.assert_frame_equal(df[mask_a], df.loc[1:1, :])
tm.assert_frame_equal(df[-mask_a], df.loc[0:0, :])
mask_b = df.b == "foo"
tm.assert_frame_equal(df[mask_b], df.loc[0:0, :])
tm.assert_frame_equal(df[-mask_b], df.loc[1:1, :])
@pytest.mark.parametrize('opname', ['eq', 'ne', 'gt', 'lt', 'ge', 'le'])
def test_df_flex_cmp_constant_return_types(self, opname):
# GH 15077, non-empty DataFrame
df = pd.DataFrame({'x': [1, 2, 3], 'y': [1., 2., 3.]})
const = 2
result = getattr(df, opname)(const).get_dtype_counts()
tm.assert_series_equal(result, pd.Series([2], ['bool']))
@pytest.mark.parametrize('opname', ['eq', 'ne', 'gt', 'lt', 'ge', 'le'])
def test_df_flex_cmp_constant_return_types_empty(self, opname):
# GH 15077 empty DataFrame
df = pd.DataFrame({'x': [1, 2, 3], 'y': [1., 2., 3.]})
const = 2
empty = df.iloc[:0]
result = getattr(empty, opname)(const).get_dtype_counts()
tm.assert_series_equal(result, pd.Series([2], ['bool']))
# -------------------------------------------------------------------
# Arithmetic
class TestFrameFlexArithmetic(object):
def test_df_add_td64_columnwise(self):
# GH 22534 Check that column-wise addition broadcasts correctly
dti = pd.date_range('2016-01-01', periods=10)
tdi = pd.timedelta_range('1', periods=10)
tser = pd.Series(tdi)
df = pd.DataFrame({0: dti, 1: tdi})
result = df.add(tser, axis=0)
expected = pd.DataFrame({0: dti + tdi,
1: tdi + tdi})
tm.assert_frame_equal(result, expected)
def test_df_add_flex_filled_mixed_dtypes(self):
# GH 19611
dti = pd.date_range('2016-01-01', periods=3)
ser = pd.Series(['1 Day', 'NaT', '2 Days'], dtype='timedelta64[ns]')
df = pd.DataFrame({'A': dti, 'B': ser})
other = pd.DataFrame({'A': ser, 'B': ser})
fill = pd.Timedelta(days=1).to_timedelta64()
result = df.add(other, fill_value=fill)
expected = pd.DataFrame(
{'A': pd.Series(['2016-01-02', '2016-01-03', '2016-01-05'],
dtype='datetime64[ns]'),
'B': ser * 2})
tm.assert_frame_equal(result, expected)
def test_arith_flex_frame(self, all_arithmetic_operators, float_frame,
mixed_float_frame):
# one instance of parametrized fixture
op = all_arithmetic_operators
def f(x, y):
# r-versions not in operator-stdlib; get op without "r" and invert
if op.startswith('__r'):
return getattr(operator, op.replace('__r', '__'))(y, x)
return getattr(operator, op)(x, y)
result = getattr(float_frame, op)(2 * float_frame)
expected = f(float_frame, 2 * float_frame)
tm.assert_frame_equal(result, expected)
# vs mix float
result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
expected = f(mixed_float_frame, 2 * mixed_float_frame)
tm.assert_frame_equal(result, expected)
_check_mixed_float(result, dtype=dict(C=None))
@pytest.mark.parametrize('op', ['__add__', '__sub__', '__mul__'])
def test_arith_flex_frame_mixed(self, op, int_frame, mixed_int_frame,
mixed_float_frame):
f = getattr(operator, op)
# vs mix int
result = getattr(mixed_int_frame, op)(2 + mixed_int_frame)
expected = f(mixed_int_frame, 2 + mixed_int_frame)
# no overflow in the uint
dtype = None
if op in ['__sub__']:
dtype = dict(B='uint64', C=None)
elif op in ['__add__', '__mul__']:
dtype = dict(C=None)
tm.assert_frame_equal(result, expected)
_check_mixed_int(result, dtype=dtype)
# vs mix float
result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
expected = f(mixed_float_frame, 2 * mixed_float_frame)
tm.assert_frame_equal(result, expected)
_check_mixed_float(result, dtype=dict(C=None))
# vs plain int
result = getattr(int_frame, op)(2 * int_frame)
expected = f(int_frame, 2 * int_frame)
tm.assert_frame_equal(result, expected)
def test_arith_flex_frame_raise(self, all_arithmetic_operators,
float_frame):
# one instance of parametrized fixture
op = all_arithmetic_operators
# Check that arrays with dim >= 3 raise
for dim in range(3, 6):
arr = np.ones((1,) * dim)
msg = "Unable to coerce to Series/DataFrame"
with tm.assert_raises_regex(ValueError, msg):
getattr(float_frame, op)(arr)
def test_arith_flex_frame_corner(self, float_frame):
const_add = float_frame.add(1)
tm.assert_frame_equal(const_add, float_frame + 1)
# corner cases
result = float_frame.add(float_frame[:0])
tm.assert_frame_equal(result, float_frame * np.nan)
result = float_frame[:0].add(float_frame)
tm.assert_frame_equal(result, float_frame * np.nan)
with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
float_frame.add(float_frame.iloc[0], fill_value=3)
with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
float_frame.add(float_frame.iloc[0], axis='index', fill_value=3)
def test_arith_flex_series(self, simple_frame):
df = simple_frame
row = df.xs('a')
col = df['two']
# after arithmetic refactor, add truediv here
ops = ['add', 'sub', 'mul', 'mod']
for op in ops:
f = getattr(df, op)
op = getattr(operator, op)
tm.assert_frame_equal(f(row), op(df, row))
tm.assert_frame_equal(f(col, axis=0), op(df.T, col).T)
# special case for some reason
tm.assert_frame_equal(df.add(row, axis=None), df + row)
# cases which will be refactored after big arithmetic refactor
tm.assert_frame_equal(df.div(row), df / row)
tm.assert_frame_equal(df.div(col, axis=0), (df.T / col).T)
# broadcasting issue in GH 7325
df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='int64')
expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
result = df.div(df[0], axis='index')
tm.assert_frame_equal(result, expected)
df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='float64')
expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
result = df.div(df[0], axis='index')
tm.assert_frame_equal(result, expected)
def test_arith_flex_zero_len_raises(self):
# GH 19522 passing fill_value to frame flex arith methods should
# raise even in the zero-length special cases
ser_len0 = pd.Series([])
df_len0 = pd.DataFrame([], columns=['A', 'B'])
df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B'])
with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
df.add(ser_len0, fill_value='E')
with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
df_len0.sub(df['A'], axis=None, fill_value=3)
class TestFrameArithmetic(object):
def test_df_add_2d_array_rowlike_broadcasts(self):
# GH#23000
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=['A', 'B', 'C'])
rowlike = arr[[1], :] # shape --> (1, ncols)
assert rowlike.shape == (1, df.shape[1])
expected = pd.DataFrame([[2, 4],
[4, 6],
[6, 8]],
columns=df.columns, index=df.index,
# specify dtype explicitly to avoid failing
# on 32bit builds
dtype=arr.dtype)
result = df + rowlike
tm.assert_frame_equal(result, expected)
result = rowlike + df
tm.assert_frame_equal(result, expected)
def test_df_add_2d_array_collike_broadcasts(self):
# GH#23000
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=['A', 'B', 'C'])
collike = arr[:, [1]] # shape --> (nrows, 1)
assert collike.shape == (df.shape[0], 1)
expected = pd.DataFrame([[1, 2],
[5, 6],
[9, 10]],
columns=df.columns, index=df.index,
# specify dtype explicitly to avoid failing
# on 32bit builds
dtype=arr.dtype)
result = df + collike
tm.assert_frame_equal(result, expected)
result = collike + df
tm.assert_frame_equal(result, expected)
def test_df_arith_2d_array_rowlike_broadcasts(self,
all_arithmetic_operators):
# GH#23000
opname = all_arithmetic_operators
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=['A', 'B', 'C'])
rowlike = arr[[1], :] # shape --> (1, ncols)
assert rowlike.shape == (1, df.shape[1])
exvals = [getattr(df.loc['A'], opname)(rowlike.squeeze()),
getattr(df.loc['B'], opname)(rowlike.squeeze()),
getattr(df.loc['C'], opname)(rowlike.squeeze())]
expected = pd.DataFrame(exvals, columns=df.columns, index=df.index)
if opname in ['__rmod__', '__rfloordiv__']:
# exvals will have dtypes [f8, i8, i8] so expected will be
# all-f8, but the DataFrame operation will return mixed dtypes
# use exvals[-1].dtype instead of "i8" for compat with 32-bit
# systems/pythons
expected[False] = expected[False].astype(exvals[-1].dtype)
result = getattr(df, opname)(rowlike)
tm.assert_frame_equal(result, expected)
def test_df_arith_2d_array_collike_broadcasts(self,
all_arithmetic_operators):
# GH#23000
opname = all_arithmetic_operators
arr = np.arange(6).reshape(3, 2)
df = pd.DataFrame(arr, columns=[True, False], index=['A', 'B', 'C'])
collike = arr[:, [1]] # shape --> (nrows, 1)
assert collike.shape == (df.shape[0], 1)
exvals = {True: getattr(df[True], opname)(collike.squeeze()),
False: getattr(df[False], opname)(collike.squeeze())}
dtype = None
if opname in ['__rmod__', '__rfloordiv__']:
# Series ops may return mixed int/float dtypes in cases where
# DataFrame op will return all-float. So we upcast `expected`
dtype = np.common_type(*[x.values for x in exvals.values()])
expected = pd.DataFrame(exvals, columns=df.columns, index=df.index,
dtype=dtype)
result = getattr(df, opname)(collike)
tm.assert_frame_equal(result, expected)
def test_df_bool_mul_int(self):
# GH 22047, GH 22163 multiplication by 1 should result in int dtype,
# not object dtype
df = pd.DataFrame([[False, True], [False, False]])
result = df * 1
# On appveyor this comes back as np.int32 instead of np.int64,
# so we check dtype.kind instead of just dtype
kinds = result.dtypes.apply(lambda x: x.kind)
assert (kinds == 'i').all()
result = 1 * df
kinds = result.dtypes.apply(lambda x: x.kind)
assert (kinds == 'i').all()
def test_td64_df_add_int_frame(self):
# GH#22696 Check that we don't dispatch to numpy implementation,
# which treats int64 as m8[ns]
tdi = pd.timedelta_range('1', periods=3)
df = tdi.to_frame()
other = pd.DataFrame([1, 2, 3], index=tdi) # indexed like `df`
with pytest.raises(TypeError):
df + other
with pytest.raises(TypeError):
other + df
with pytest.raises(TypeError):
df - other
with pytest.raises(TypeError):
other - df
|
# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Runs Chromium's IndexedDB performance test. These test:
Databases:
create/delete
Keys:
create/delete
Indexes:
create/delete
Data access:
Random read/write
Read cache
Cursors:
Read & random writes
Walking multiple
Seeking.
"""
import json
import os
from metrics import memory
from metrics import power
from metrics import v8_object_stats
from telemetry import benchmark
from telemetry.core import util
from telemetry.page import page_measurement
from telemetry.page import page_set
from telemetry.value import scalar
_V8_COUNTER_NAMES = [
'V8.OsMemoryAllocated',
]
class _IndexedDbMeasurement(page_measurement.PageMeasurement):
def __init__(self, *args, **kwargs):
super(_IndexedDbMeasurement, self).__init__(*args, **kwargs)
self._memory_metric = None
self._power_metric = None
self._v8_object_stats_metric = None
def WillStartBrowser(self, browser):
"""Initialize metrics once right before the browser has been launched."""
self._power_metric = power.PowerMetric(browser)
def DidStartBrowser(self, browser):
"""Initialize metrics once right after the browser has been launched."""
self._memory_metric = memory.MemoryMetric(browser)
self._v8_object_stats_metric = (
v8_object_stats.V8ObjectStatsMetric(_V8_COUNTER_NAMES))
def DidNavigateToPage(self, page, tab):
self._memory_metric.Start(page, tab)
self._power_metric.Start(page, tab)
self._v8_object_stats_metric.Start(page, tab)
def MeasurePage(self, page, tab, results):
tab.WaitForDocumentReadyStateToBeComplete()
tab.WaitForJavaScriptExpression(
'window.document.cookie.indexOf("__done=1") >= 0', 600)
self._power_metric.Stop(page, tab)
self._memory_metric.Stop(page, tab)
self._v8_object_stats_metric.Stop(page, tab)
self._memory_metric.AddResults(tab, results)
self._power_metric.AddResults(tab, results)
self._v8_object_stats_metric.AddResults(tab, results)
js_get_results = "JSON.stringify(automation.getResults());"
result_dict = json.loads(tab.EvaluateJavaScript(js_get_results))
total = 0.0
for key in result_dict:
if key == 'OverallTestDuration':
continue
msec = float(result_dict[key])
results.AddValue(scalar.ScalarValue(
results.current_page, key, 'ms', msec, important=False))
total += msec
results.AddValue(scalar.ScalarValue(
results.current_page, 'Total Perf', 'ms', total))
def CustomizeBrowserOptions(self, options):
memory.MemoryMetric.CustomizeBrowserOptions(options)
power.PowerMetric.CustomizeBrowserOptions(options)
v8_object_stats.V8ObjectStatsMetric.CustomizeBrowserOptions(options)
class IndexedDb(benchmark.Benchmark):
"""Chromium's IndexedDB Performance tests."""
test = _IndexedDbMeasurement
def CreatePageSet(self, options):
indexeddb_dir = os.path.join(util.GetChromiumSrcDir(), 'chrome', 'test',
'data', 'indexeddb')
ps = page_set.PageSet(file_path=indexeddb_dir)
ps.AddPageWithDefaultRunNavigate('file://perf_test.html')
return ps
|
# -*- coding: utf-8 -*-
"""
***************************************************************************
GrassUtils.py
---------------------
Date : February 2015
Copyright : (C) 2014-2015 by Victor Olaya
Email : volayaf at gmail dot com
***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************
"""
from builtins import str
from builtins import object
__author__ = 'Victor Olaya'
__date__ = 'February 2015'
__copyright__ = '(C) 2014-2015, Victor Olaya'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
import stat
import shutil
import subprocess
import os
from qgis.core import QgsApplication
from qgis.PyQt.QtCore import QCoreApplication
from processing.core.ProcessingConfig import ProcessingConfig
from processing.core.ProcessingLog import ProcessingLog
from processing.tools.system import userFolder, isWindows, isMac, tempFolder, mkdir
from processing.tests.TestData import points
class Grass7Utils(object):
GRASS_REGION_XMIN = 'GRASS7_REGION_XMIN'
GRASS_REGION_YMIN = 'GRASS7_REGION_YMIN'
GRASS_REGION_XMAX = 'GRASS7_REGION_XMAX'
GRASS_REGION_YMAX = 'GRASS7_REGION_YMAX'
GRASS_REGION_CELLSIZE = 'GRASS7_REGION_CELLSIZE'
GRASS_FOLDER = 'GRASS7_FOLDER'
GRASS_LOG_COMMANDS = 'GRASS7_LOG_COMMANDS'
GRASS_LOG_CONSOLE = 'GRASS7_LOG_CONSOLE'
GRASS_HELP_PATH = 'GRASS_HELP_PATH'
sessionRunning = False
sessionLayers = {}
projectionSet = False
isGrass7Installed = False
version = None
@staticmethod
def grassBatchJobFilename():
'''This is used in Linux. This is the batch job that we assign to
GRASS_BATCH_JOB and then call GRASS and let it do the work
'''
filename = 'grass7_batch_job.sh'
batchfile = os.path.join(userFolder(), filename)
return batchfile
@staticmethod
def grassScriptFilename():
'''This is used in windows. We create a script that initializes
GRASS and then uses grass commands
'''
filename = 'grass7_script.bat'
filename = os.path.join(userFolder(), filename)
return filename
@staticmethod
def installedVersion(run=False):
if Grass7Utils.isGrass7Installed and not run:
return Grass7Utils.version
if Grass7Utils.grassPath() is None:
return None
for command in ["grass73", "grass72", "grass71", "grass70", "grass"]:
with subprocess.Popen(
["{} -v".format(command)],
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
) as proc:
try:
lines = proc.stdout.readlines()
for line in lines:
if "GRASS GIS " in line:
line = line.split(" ")[-1].strip()
if line.startswith("7."):
Grass7Utils.version = line
Grass7Utils.command = command
return Grass7Utils.version
except:
pass
return None
@staticmethod
def grassPath():
if not isWindows() and not isMac():
return ''
folder = ProcessingConfig.getSetting(Grass7Utils.GRASS_FOLDER) or ''
if not os.path.exists(folder):
folder = None
if folder is None:
if isWindows():
if "OSGEO4W_ROOT" in os.environ:
testfolder = os.path.join(str(os.environ['OSGEO4W_ROOT']), "apps")
else:
testfolder = str(QgsApplication.prefixPath())
testfolder = os.path.join(testfolder, 'grass')
if os.path.isdir(testfolder):
for subfolder in os.listdir(testfolder):
if subfolder.startswith('grass-7'):
folder = os.path.join(testfolder, subfolder)
break
else:
folder = os.path.join(str(QgsApplication.prefixPath()), 'grass7')
if not os.path.isdir(folder):
folder = '/Applications/GRASS-7.0.app/Contents/MacOS'
return folder or ''
@staticmethod
def grassDescriptionPath():
return os.path.join(os.path.dirname(__file__), 'description')
@staticmethod
def createGrass7Script(commands):
folder = Grass7Utils.grassPath()
script = Grass7Utils.grassScriptFilename()
gisrc = os.path.join(userFolder(), 'processing.gisrc7') # FIXME: use temporary file
# Temporary gisrc file
with open(gisrc, 'w') as output:
location = 'temp_location'
gisdbase = Grass7Utils.grassDataFolder()
output.write('GISDBASE: ' + gisdbase + '\n')
output.write('LOCATION_NAME: ' + location + '\n')
output.write('MAPSET: PERMANENT \n')
output.write('GRASS_GUI: text\n')
with open(script, 'w') as output:
output.write('set HOME=' + os.path.expanduser('~') + '\n')
output.write('set GISRC=' + gisrc + '\n')
output.write('set WINGISBASE=' + folder + '\n')
output.write('set GISBASE=' + folder + '\n')
output.write('set GRASS_PROJSHARE=' + os.path.join(folder, 'share', 'proj') + '\n')
output.write('set GRASS_MESSAGE_FORMAT=plain\n')
# Replacement code for etc/Init.bat
output.write('if "%GRASS_ADDON_PATH%"=="" set PATH=%WINGISBASE%\\bin;%WINGISBASE%\\lib;%PATH%\n')
output.write('if not "%GRASS_ADDON_PATH%"=="" set PATH=%WINGISBASE%\\bin;%WINGISBASE%\\lib;%GRASS_ADDON_PATH%;%PATH%\n')
output.write('\n')
output.write('set GRASS_VERSION=' + Grass7Utils.installedVersion() + '\n')
output.write('if not "%LANG%"=="" goto langset\n')
output.write('FOR /F "usebackq delims==" %%i IN (`"%WINGISBASE%\\etc\\winlocale"`) DO @set LANG=%%i\n')
output.write(':langset\n')
output.write('\n')
output.write('set PATHEXT=%PATHEXT%;.PY\n')
output.write('set PYTHONPATH=%PYTHONPATH%;%WINGISBASE%\\etc\\python;%WINGISBASE%\\etc\\wxpython\\n')
output.write('\n')
output.write('g.gisenv.exe set="MAPSET=PERMANENT"\n')
output.write('g.gisenv.exe set="LOCATION=' + location + '"\n')
output.write('g.gisenv.exe set="LOCATION_NAME=' + location + '"\n')
output.write('g.gisenv.exe set="GISDBASE=' + gisdbase + '"\n')
output.write('g.gisenv.exe set="GRASS_GUI=text"\n')
for command in commands:
Grass7Utils.writeCommand(output, command)
output.write('\n')
output.write('exit\n')
@staticmethod
def createGrass7BatchJobFileFromGrass7Commands(commands):
with open(Grass7Utils.grassBatchJobFilename(), 'w') as fout:
for command in commands:
Grass7Utils.writeCommand(fout, command)
fout.write('exit')
@staticmethod
def grassMapsetFolder():
folder = os.path.join(Grass7Utils.grassDataFolder(), 'temp_location')
mkdir(folder)
return folder
@staticmethod
def grassDataFolder():
tempfolder = os.path.join(tempFolder(), 'grassdata')
mkdir(tempfolder)
return tempfolder
@staticmethod
def createTempMapset():
'''Creates a temporary location and mapset(s) for GRASS data
processing. A minimal set of folders and files is created in the
system's default temporary directory. The settings files are
written with sane defaults, so GRASS can do its work. The mapset
projection will be set later, based on the projection of the first
input image or vector
'''
folder = Grass7Utils.grassMapsetFolder()
mkdir(os.path.join(folder, 'PERMANENT'))
mkdir(os.path.join(folder, 'PERMANENT', '.tmp'))
Grass7Utils.writeGrass7Window(os.path.join(folder, 'PERMANENT', 'DEFAULT_WIND'))
with open(os.path.join(folder, 'PERMANENT', 'MYNAME'), 'w') as outfile:
outfile.write(
'QGIS GRASS GIS 7 interface: temporary data processing location.\n')
Grass7Utils.writeGrass7Window(os.path.join(folder, 'PERMANENT', 'WIND'))
mkdir(os.path.join(folder, 'PERMANENT', 'sqlite'))
with open(os.path.join(folder, 'PERMANENT', 'VAR'), 'w') as outfile:
outfile.write('DB_DRIVER: sqlite\n')
outfile.write('DB_DATABASE: $GISDBASE/$LOCATION_NAME/$MAPSET/sqlite/sqlite.db\n')
@staticmethod
def writeGrass7Window(filename):
with open(filename, 'w') as out:
out.write('proj: 0\n')
out.write('zone: 0\n')
out.write('north: 1\n')
out.write('south: 0\n')
out.write('east: 1\n')
out.write('west: 0\n')
out.write('cols: 1\n')
out.write('rows: 1\n')
out.write('e-w resol: 1\n')
out.write('n-s resol: 1\n')
out.write('top: 1\n')
out.write('bottom: 0\n')
out.write('cols3: 1\n')
out.write('rows3: 1\n')
out.write('depths: 1\n')
out.write('e-w resol3: 1\n')
out.write('n-s resol3: 1\n')
out.write('t-b resol: 1\n')
@staticmethod
def prepareGrass7Execution(commands):
env = os.environ.copy()
if isWindows():
Grass7Utils.createGrass7Script(commands)
command = ['cmd.exe', '/C ', Grass7Utils.grassScriptFilename()]
else:
gisrc = os.path.join(userFolder(), 'processing.gisrc7')
env['GISRC'] = gisrc
env['GRASS_MESSAGE_FORMAT'] = 'plain'
env['GRASS_BATCH_JOB'] = Grass7Utils.grassBatchJobFilename()
if 'GISBASE' in env:
del env['GISBASE']
Grass7Utils.createGrass7BatchJobFileFromGrass7Commands(commands)
os.chmod(Grass7Utils.grassBatchJobFilename(), stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE)
if isMac() and os.path.exists(os.path.join(Grass7Utils.grassPath(), 'grass.sh')):
command = os.path.join(Grass7Utils.grassPath(), 'grass.sh') + ' ' \
+ os.path.join(Grass7Utils.grassMapsetFolder(), 'PERMANENT')
else:
command = Grass7Utils.command + ' ' + os.path.join(Grass7Utils.grassMapsetFolder(), 'PERMANENT')
return command, env
@staticmethod
def executeGrass7(commands, feedback, outputCommands=None):
loglines = []
loglines.append(Grass7Utils.tr('GRASS GIS 7 execution console output'))
grassOutDone = False
command, grassenv = Grass7Utils.prepareGrass7Execution(commands)
with subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
env=grassenv
) as proc:
for line in iter(proc.stdout.readline, ''):
if 'GRASS_INFO_PERCENT' in line:
try:
feedback.setProgress(int(line[len('GRASS_INFO_PERCENT') + 2:]))
except:
pass
else:
if 'r.out' in line or 'v.out' in line:
grassOutDone = True
loglines.append(line)
feedback.pushConsoleInfo(line)
# Some GRASS scripts, like r.mapcalculator or r.fillnulls, call
# other GRASS scripts during execution. This may override any
# commands that are still to be executed by the subprocess, which
# are usually the output ones. If that is the case runs the output
# commands again.
if not grassOutDone and outputCommands:
command, grassenv = Grass7Utils.prepareGrass7Execution(outputCommands)
with subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
env=grassenv
) as proc:
for line in iter(proc.stdout.readline, ''):
if 'GRASS_INFO_PERCENT' in line:
try:
feedback.setProgress(int(
line[len('GRASS_INFO_PERCENT') + 2:]))
except:
pass
else:
loglines.append(line)
feedback.pushConsoleInfo(line)
if ProcessingConfig.getSetting(Grass7Utils.GRASS_LOG_CONSOLE):
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
# GRASS session is used to hold the layers already exported or
# produced in GRASS between multiple calls to GRASS algorithms.
# This way they don't have to be loaded multiple times and
# following algorithms can use the results of the previous ones.
# Starting a session just involves creating the temp mapset
# structure
@staticmethod
def startGrass7Session():
if not Grass7Utils.sessionRunning:
Grass7Utils.createTempMapset()
Grass7Utils.sessionRunning = True
# End session by removing the temporary GRASS mapset and all
# the layers.
@staticmethod
def endGrass7Session():
shutil.rmtree(Grass7Utils.grassMapsetFolder(), True)
Grass7Utils.sessionRunning = False
Grass7Utils.sessionLayers = {}
Grass7Utils.projectionSet = False
@staticmethod
def getSessionLayers():
return Grass7Utils.sessionLayers
@staticmethod
def addSessionLayers(exportedLayers):
Grass7Utils.sessionLayers = dict(
list(Grass7Utils.sessionLayers.items()) +
list(exportedLayers.items()))
@staticmethod
def checkGrass7IsInstalled(ignorePreviousState=False):
if isWindows():
path = Grass7Utils.grassPath()
if path == '':
return Grass7Utils.tr(
'GRASS GIS 7 folder is not configured. Please configure '
'it before running GRASS GIS 7 algorithms.')
cmdpath = os.path.join(path, 'bin', 'r.out.gdal.exe')
if not os.path.exists(cmdpath):
return Grass7Utils.tr(
'The specified GRASS 7 folder "{}" does not contain '
'a valid set of GRASS 7 modules.\nPlease, go to the '
'Processing settings dialog, and check that the '
'GRASS 7\nfolder is correctly configured'.format(os.path.join(path, 'bin')))
if not ignorePreviousState:
if Grass7Utils.isGrass7Installed:
return
try:
from processing import runalg
result = runalg(
'grass7:v.voronoi',
points(),
False,
False,
None,
-1,
0.0001,
0,
None,
)
if not os.path.exists(result['output']):
return Grass7Utils.tr(
'It seems that GRASS GIS 7 is not correctly installed and '
'configured in your system.\nPlease install it before '
'running GRASS GIS 7 algorithms.')
except:
return Grass7Utils.tr(
'Error while checking GRASS GIS 7 installation. GRASS GIS 7 '
'might not be correctly configured.\n')
Grass7Utils.isGrass7Installed = True
@staticmethod
def tr(string, context=''):
if context == '':
context = 'Grass7Utils'
return QCoreApplication.translate(context, string)
@staticmethod
def writeCommand(output, command):
try:
# Python 2
output.write(command.encode('utf8') + '\n')
except TypeError:
# Python 3
output.write(command + '\n')
@staticmethod
def grassHelpPath():
helpPath = ProcessingConfig.getSetting(Grass7Utils.GRASS_HELP_PATH)
if helpPath is None:
if isWindows():
localPath = os.path.join(Grass7Utils.grassPath(), 'docs/html')
if os.path.exists(localPath):
helpPath = os.path.abspath(localPath)
elif isMac():
localPath = '/Applications/GRASS-7.0.app/Contents/MacOS/docs/html'
if os.path.exists(localPath):
helpPath = os.path.abspath(localPath)
else:
searchPaths = ['/usr/share/doc/grass-doc/html',
'/opt/grass/docs/html',
'/usr/share/doc/grass/docs/html']
for path in searchPaths:
if os.path.exists(path):
helpPath = os.path.abspath(path)
break
return helpPath if helpPath is not None else 'http://grass.osgeo.org/{}/manuals/'.format(Grass7Utils.command)
|
"""
Author: Shraey Bhatia
Date: October 2016
File: extract.py
This file uses WikiExtractor tool to generate documents from wikipedia xml dump.
WikExtractor tool can be found at https://github.com/attardi/wikiextractor.
If you use a diffferent path than to one mentioned in readme update it in main_train.py
Arguments for this file are taken from there.
"""
import os
import argparse
import sys
# The arguments for WikiExtractor. These parameters have been explained in main_train.py
parser = argparse.ArgumentParser()
parser.add_argument("wiki_extractor_path")
parser.add_argument("input_dump") # The Xml dump
parser.add_argument("size")
parser.add_argument("template")
parser.add_argument("output_processed_dir") # the output directory
args = parser.parse_args()
# Checks if the output directory specified already exists. If it does removes it.
if os.path.isdir(args.output_processed_dir):
del_query = "rm -r "+args.output_processed_dir
os.system(del_query)
# Creates the output directory.
query1 = "mkdir "+args.output_processed_dir
os.system(query1)
query2 = "python "+args.wiki_extractor_path+" "+args.input_dump +" -o" +args.output_processed_dir +" -b " +args.size +" --"+args.template
os.system(query2)
|
# vi: ts=4 expandtab
#
# Copyright (C) 2011 Canonical Ltd.
# Copyright (C) 2012 Hewlett-Packard Development Company, L.P.
#
# Author: Scott Moser <[email protected]>
# Author: Juerg Haefliger <[email protected]>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3, as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
Scripts Per Boot
----------------
**Summary:** run per boot scripts
Any scripts in the ``scripts/per-boot`` directory on the datasource will be run
every time the system boots. Scripts will be run in alphabetical order. This
module does not accept any config keys.
**Internal name:** ``cc_scripts_per_boot``
**Module frequency:** per always
**Supported distros:** all
"""
import os
from cloudinit import util
from cloudinit.settings import PER_ALWAYS
frequency = PER_ALWAYS
SCRIPT_SUBDIR = 'per-boot'
def handle(name, _cfg, cloud, log, _args):
# Comes from the following:
# https://forums.aws.amazon.com/thread.jspa?threadID=96918
runparts_path = os.path.join(cloud.get_cpath(), 'scripts', SCRIPT_SUBDIR)
try:
util.runparts(runparts_path)
except Exception:
log.warn("Failed to run module %s (%s in %s)",
name, SCRIPT_SUBDIR, runparts_path)
raise
|
# -*- coding: utf-8 -*-
import os
import shutil
import unittest
from gits import fs_utils
test_dir_root = os.path.dirname(os.path.realpath(__file__))
class MethodsInput(unittest.TestCase):
"""
Tests behavior of methods which take input arguments.
"""
scratch_dir = os.path.join(test_dir_root, "scratch")
path_to_dummy_file = os.path.join(scratch_dir, "dummy.txt")
good_input_dict = {"dir1": {}}
def setUp(self):
"""
Creates the scratch dir.
Creates a dummy file in the scratch dir.
"""
os.mkdir(self.scratch_dir)
with open(self.path_to_dummy_file, "w"):
pass
def tearDown(self):
"""
Removes scratch dir and contents.
"""
shutil.rmtree(self.scratch_dir)
def test_dict_to_fs_fs_dict_non_dict(self):
"""
First argument to dict_to_fs must be a dictionary.
"""
self.assertRaises(TypeError, fs_utils.dict_to_fs, "not a dict", self.scratch_dir)
def test_dict_to_fs_fs_dict_values_non_dict_string(self):
"""
Values of fs_dict must be either strings or dictionaries.
"""
bad_input = {"neither_string_nor_dict": 42.}
self.assertRaises(TypeError, fs_utils.dict_to_fs, bad_input, self.scratch_dir)
def test_dict_to_fs_fqpn_root_non_str(self):
"""
Second argument to dict_to_fs must be a string.
"""
self.assertRaises(TypeError, fs_utils.dict_to_fs, self.good_input_dict, 42.)
def test_dict_to_fs_fqpn_root_string(self):
"""
Second argument to dict_to_fs can be str.
"""
try:
fs_utils.dict_to_fs(self.good_input_dict, str(self.scratch_dir))
except:
self.fail("An exception was raised, so this method can't handle strings.")
def test_dict_to_fs_fqpn_root_unicode(self):
"""
Second argument to dict_to_fs can be unicode.
"""
try:
fs_utils.dict_to_fs(self.good_input_dict, unicode(self.scratch_dir))
except:
self.fail("An exception was raised, so this method can't handle unicode.")
def test_dict_to_fs_fqpn_root_nonexistant_path(self):
"""
Second arg to dict_to_fs must correspond to exitant path.
"""
nonexistant_subdir = "does_not_exist"
bad_fqpn_root = os.path.join(self.scratch_dir, nonexistant_subdir)
self.assertRaises(OSError, fs_utils.dict_to_fs, self.good_input_dict, bad_fqpn_root)
def test_dict_to_fs_fqpn_root_non_directory_path(self):
"""
Second arg to dict_to_fs must correspond to a dir, not a file.
"""
self.assertRaises(OSError, fs_utils.dict_to_fs, self.good_input_dict, self.path_to_dummy_file)
class MethodsFunctionality(unittest.TestCase):
"""
Tests proper functionality of the methods.
"""
scratch_dir = os.path.join(test_dir_root, "scratch")
def setUp(self):
"""
Creates a scratch directory for the tests.
"""
os.mkdir(self.scratch_dir)
def tearDown(self):
"""
Removes the scratch dir (and its contents).
"""
shutil.rmtree(self.scratch_dir)
def test_dict_to_fs_filename(self):
"""
dict_to_fs should be able to create a file with a specified filename.
"""
fs_dict = {"dummy.txt": ""}
fs_utils.dict_to_fs(fs_dict, self.scratch_dir)
scratch_names = os.listdir(self.scratch_dir)
self.assertEqual(scratch_names, fs_dict.keys())
def test_dict_to_fs_isfile(self):
"""
dict_to_fs should be able to create a file.
"""
dummy_filename = "dummy.txt"
fs_dict = {dummy_filename: ""}
fs_utils.dict_to_fs(fs_dict, self.scratch_dir)
dummy_fqpn = os.path.join(self.scratch_dir, dummy_filename)
self.assertTrue(os.path.isfile(dummy_fqpn))
def test_dict_to_fs_empty_file(self):
"""
An empty string should generate an empty file.
"""
dummy_filename = "dummy.txt"
fs_dict = {dummy_filename: ""}
fs_utils.dict_to_fs(fs_dict, self.scratch_dir)
dummy_fqpn = os.path.join(self.scratch_dir, dummy_filename)
self.assertEqual(os.path.getsize(dummy_fqpn), 0)
def test_dict_to_fs_nonempty_file(self):
"""
A nonempty string should generate a nonempty file.
"""
dummy_filename = "dummy.txt"
fs_dict = {dummy_filename: "Hello world.\n"}
fs_utils.dict_to_fs(fs_dict, self.scratch_dir)
dummy_fqpn = os.path.join(self.scratch_dir, dummy_filename)
self.assertTrue(os.path.getsize(dummy_fqpn) > 0)
def test_dict_to_fs_isdir(self):
"""
dict_to_fs should be able to create a directory.
"""
dummy_dirname = "dummy"
fs_dict = {dummy_dirname: {}}
fs_utils.dict_to_fs(fs_dict, self.scratch_dir)
dummy_fqpn = os.path.join(self.scratch_dir, dummy_dirname)
self.assertTrue(os.path.isdir(dummy_fqpn))
def test_dict_to_fs_dir_isempty(self):
"""
dict_to_fs should be able to create an empty directory.
"""
dummy_dirname = "dummy"
fs_dict = {dummy_dirname: {}}
fs_utils.dict_to_fs(fs_dict, self.scratch_dir)
dummy_fqpn = os.path.join(self.scratch_dir, dummy_dirname)
should_be_empty_list = os.listdir(os.path.join(self.scratch_dir, dummy_dirname))
self.assertEqual(should_be_empty_list, [])
def test_dict_to_fs_dir_nonempty(self):
"""
dict_to_fs should be able to create a populated directory.
"""
dummy_dirname = "dummy"
fs_dict = {dummy_dirname: {"test_file.txt":""}}
fs_utils.dict_to_fs(fs_dict, self.scratch_dir)
dummy_fqpn = os.path.join(self.scratch_dir, dummy_dirname)
should_not_be_empty_list = os.listdir(os.path.join(self.scratch_dir, dummy_dirname))
self.assertTrue(len(should_not_be_empty_list) > 0)
|
## FD_1D_DX4_DT4_LW.py 1-D acoustic Finite-Difference modelling
# GNU General Public License v3.0
#
# Author: Florian Wittkamp 2016
#
# Finite-Difference acoustic seismic wave simulation
# Discretization of the first-order acoustic wave equation
#
# Temporal second-order accuracy O(DT^4)
# Spatial fourth-order accuracy O(DX^4)
#
# Theory to Lax-Wendroff method is given in:
# Dablain, M. A. (1986).
# The application of high-order differencing to the scalar wave equation.
# Geophysics, 51(1), 54-66.
## Initialisation
print(" ")
print("Starting FD_1D_DX4_DT4_LW")
from numpy import *
import time as tm
import matplotlib.pyplot as plt
## Input Parameter
# Discretization
c1=20 # Number of grid points per dominant wavelength
c2=0.5 # CFL-Number
nx=2000 # Number of grid points
T=10 # Total propagation time
# Source Signal
f0= 10 # Center frequency Ricker-wavelet
q0= 1 # Maximum amplitude Ricker-Wavelet
xscr = 100 # Source position (in grid points)
# Receiver
xrec1=400 # Position Reciever 1 (in grid points)
xrec2=800 # Position Reciever 2 (in grid points)
xrec3=1800 # Position Reciever 3 (in grid points)
# Velocity and density
modell_v = hstack((1000*ones((around(nx/2)),float),1500*ones((around(nx/2)),float)))
rho=hstack((1*ones((around(nx/2)),float),1.5*ones((around(nx/2)),float)))
## Preparation
# Init wavefields
vx=zeros((nx),float)
p=zeros((nx),float)
# Calculate first Lame-Paramter
l=rho * modell_v * modell_v
cmin=min(modell_v.flatten()) # Lowest P-wave velocity
cmax=max(modell_v.flatten()) # Highest P-wave velocity
fmax=2*f0 # Maximum frequency
dx=cmin/(fmax*c1) # Spatial discretization (in m)
dt=dx/(cmax)*c2 # Temporal discretization (in s)
lampda_min=cmin/fmax # Smallest wavelength
# Output model parameter:
print("Model size: x:",dx*nx,"in m")
print("Temporal discretization: ",dt," s")
print("Spatial discretization: ",dx," m")
print("Number of gridpoints per minimum wavelength: ",lampda_min/dx)
# Create space and time vector
x=arange(0,dx*nx,dx) # Space vector
t=arange(0,T,dt) # Time vector
nt=size(t) # Number of time steps
# Plotting model
plt.figure(1)
plt.plot(x,modell_v)
plt.ylabel('VP in m/s')
plt.xlabel('Depth in m')
plt.figure(2)
plt.plot(x,rho)
plt.ylabel('Density in g/cm^3')
plt.xlabel('Depth in m')
plt.draw()
plt.pause(0.001)
# Source signal - Ricker-wavelet
tau=pi*f0*(t-1.5/f0)
q=q0*(1-2*tau**2)*exp(-tau**2)
# Plotting source signal
plt.figure(3)
plt.plot(t,q)
plt.title('Source signal Ricker-Wavelet')
plt.ylabel('Amplitude')
plt.xlabel('Time in s')
plt.draw()
plt.pause(0.001)
# Init Seismograms
Seismogramm=zeros((3,nt),float); # Three seismograms
# Calculation of some coefficients
i_dx=1.0/(dx)
i_dx3=1.0/(dx**3)
c9=dt**3/24.0
## Time stepping
print("Starting time stepping...")
tic=tm.clock()
for n in range(2,nt):
# Inject source wavelet
p[xscr]=p[xscr]+q[n]
# Update velocity
for kx in range(5,nx-4):
# Calculating spatial derivative
p_x=i_dx*9.0/8.0*(p[kx+1]-p[kx])-i_dx*1.0/24.0.0*(p[kx+2]-p[kx-1])
p_xxx=i_dx3*(-3.0)*(p[kx+1]-p[kx])+i_dx3*(1)*(p[kx+2]-p[kx-1])
# Update velocity
vx[kx]=vx[kx]-dt/rho[kx]*p_x-l[kx]*c9*1/(rho[kx]**2.0)*(p_xxx)
# Update pressure
for kx in range(5,nx-4):
# Calculating spatial derivative
vx_x= i_dx*9.0/8.0*(vx[kx]-vx[kx-1])-i_dx*1.0/24.0*(vx[kx+1]-vx[kx-2])
vx_xxx=i_dx3*(-3.0)*(vx[kx]-vx[kx-1])+i_dx3*(1)*(vx[kx+1]-vx[kx-2])
# Update pressure
p[kx]=p[kx]-l[kx]*dt*(vx_x)-l[kx]**2*c9*1/(rho[kx])*(vx_xxx)
# Save seismograms
Seismogramm[0,n]=p[xrec1]
Seismogramm[1,n]=p[xrec2]
Seismogramm[2,n]=p[xrec3]
toc = tm.clock()
time=toc-tic
## Plot seismograms
plt.figure(4)
plt.plot(t,Seismogramm[0,:])
plt.title('Seismogram 1')
plt.ylabel('Amplitude')
plt.xlabel('Time in s')
plt.figure(5)
plt.plot(t,Seismogramm[1,:])
plt.title('Seismogram 2')
plt.ylabel('Amplitude')
plt.xlabel('Time in s')
plt.figure(6)
plt.plot(t,Seismogramm[2,:])
plt.title('Seismogram 3')
plt.ylabel('Amplitude')
plt.xlabel('Time in s')
plt.draw()
plt.show()
print(" ")
|
# Copyright (C) 2015 by Clearcode <http://clearcode.cc>
# and associates (see AUTHORS).
# This file is part of matchbox.
# matchbox is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# matchbox is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with matchbox. If not, see <http://www.gnu.org/licenses/>.
"""Single value MatchBox idea implementation."""
from __future__ import absolute_import
from matchbox.basebox import BaseBox
class MatchBox(BaseBox):
"""
MatchBox for classifying objects by single-value characteristic.
Example:
+--------+-------+-------------------------+
| Object | Match | Characteristic's values |
+========+=======+=========================+
| Ob1 | False | 1 |
+--------+-------+-------------------------+
| Ob2 | True | 3 |
+--------+-------+-------------------------+
| Ob3 | False | 5 |
+--------+-------+-------------------------+
| Ob4 | False | |
+--------+-------+-------------------------+
| Ob5 | True | 1 |
+--------+-------+-------------------------+
Will result in matchbox'es index:
+-----------+-----------------+
| Attribute | Matched Objects |
+===========+=================+
| 1 | Ob1, Ob2 |
+-----------+-----------------+
| 3 | Ob5 |
+-----------+-----------------+
| 5 | Ob2, Ob3, Ob5 |
+-----------+-----------------+
| Any new | Ob2, Ob5 |
+-----------+-----------------+
"""
def add(self, indexed_object):
"""
Add object to index.
:param object indexed_object: single object to add to box's index
"""
characteristic_value = getattr(indexed_object, self._characteristic)
if characteristic_value is None:
return
is_matching = getattr(indexed_object, self._characteristic + '_match', True)
# if object is not matching given characteristic, we should add it directly to index.
if not is_matching:
self.index[characteristic_value].add(indexed_object)
else:
# access key to trigger copy of excluded.
# Since now the value becomes known.
self.index[characteristic_value]
# we add object to each value in index that's not it's characteristic's value
for existing_value in self.index:
if existing_value == characteristic_value:
continue
self.index[existing_value].add(indexed_object)
# and make sure for every new value it'll be excluded as well
self.exclude_unknown.add(indexed_object)
|
from django.core.management.base import BaseCommand, CommandError
from django.conf import settings
from harvest import untappd
class Command(BaseCommand):
args = '<poll_id poll_id ...>'
help = 'Closes the specified poll for voting'
def handle(self, *args, **options):
cmd = args[0]
u = untappd.UntappdApi(settings.HARVEST_UNTAPPD_CLIENT_ENDPOINT)
if cmd == "venue":
venue_id = args[1]
venue = u.foursquare_id_to_untappd(venue_id)
if cmd == "fs":
venue_id = args[1]
venue = u.foursquare_id_to_untappd(venue_id)
print venue
if cmd == "checkins":
venue_id = args[1]
checkins = u.get_venue_checkins(venue_id=venue_id)
for checkin in checkins:
print "%s" % (checkin)
if cmd == "fscheckins":
venue_id = args[1]
checkins = u.get_venue_checkins(foursquare_venue_id=venue_id)
for checkin in checkins:
print "%s" % (checkin)
if cmd == "limit":
print check_limit()
if cmd == "suburb":
suburb = args[1]
venues = u.get_venues_for_suburb(suburb)
for venue in venues:
print "%s: %s" % (venue['id'], venue['name'])
self.stdout.write('Succcess')
|
import unittest
from satellite import tree_from_traversals
# Tests adapted from `problem-specifications//canonical-data.json` @ v2.0.0
class SatelliteTest(unittest.TestCase):
def test_empty_tree(self):
preorder = []
inorder = []
expected = {}
self.assertEqual(tree_from_traversals(preorder, inorder), expected)
def test_tree_with_one_item(self):
preorder = ["a"]
inorder = ["a"]
expected = {"v": "a", "l": {}, "r": {}}
self.assertEqual(tree_from_traversals(preorder, inorder), expected)
def test_tree_with_many_items(self):
preorder = ["a", "i", "x", "f", "r"]
inorder = ["i", "a", "f", "x", "r"]
expected = {
"v": "a",
"l": {"v": "i", "l": {}, "r": {}},
"r": {
"v": "x",
"l": {"v": "f", "l": {}, "r": {}},
"r": {"v": "r", "l": {}, "r": {}},
},
}
self.assertEqual(tree_from_traversals(preorder, inorder), expected)
def test_reject_traversals_of_different_length(self):
preorder = ["a", "b"]
inorder = ["b", "a", "r"]
with self.assertRaisesWithMessage(ValueError):
tree_from_traversals(preorder, inorder)
def test_reject_inconsistent_traversals_of_same_length(self):
preorder = ["x", "y", "z"]
inorder = ["a", "b", "c"]
with self.assertRaisesWithMessage(ValueError):
tree_from_traversals(preorder, inorder)
def test_reject_traversals_with_repeated_items(self):
preorder = ["a", "b", "a"]
inorder = ["b", "a", "a"]
with self.assertRaisesWithMessage(ValueError):
tree_from_traversals(preorder, inorder)
# Utility functions
def assertRaisesWithMessage(self, exception):
return self.assertRaisesRegex(exception, r".+")
if __name__ == "__main__":
unittest.main()
|
import arrayfire as af
import numpy as np
import pylab as pl
from bolt.lib.physical_system import physical_system
from bolt.lib.nonlinear_solver.nonlinear_solver \
import nonlinear_solver
from bolt.lib.nonlinear_solver.tests.performance.input_files \
import domain
from bolt.lib.nonlinear_solver.tests.performance.input_files \
import boundary_conditions
from bolt.lib.nonlinear_solver.tests.performance.input_files \
import params
from bolt.lib.nonlinear_solver.tests.performance.input_files \
import initialize
import bolt.src.nonrelativistic_boltzmann.advection_terms as advection_terms
import bolt.src.nonrelativistic_boltzmann.collision_operator \
as collision_operator
import bolt.src.nonrelativistic_boltzmann.moment_defs as moment_defs
# Defining the physical system to be solved:
system = physical_system(domain,
boundary_conditions,
params,
initialize,
advection_terms,
collision_operator.BGK,
moment_defs
)
# Defining a nonlinear solver object:
nls = nonlinear_solver(system, True)
nls.strang_timestep(0.001)
af.sync()
for i in range(100):
nls.strang_timestep(0.001)
af.sync()
nls.print_performance_timings(101)
|
import json
from django.forms.widgets import Widget
from django.conf import settings
from django.utils.safestring import mark_safe
from django.template.loader import render_to_string
from collections import OrderedDict
from react_cms.finders import ComponentFinder
class ResourceEditorWidget(Widget):
template_name = 'react_cms/widgets/resource_editor.html'
def render(self, name, value, attrs=None, renderer=None):
context = {'value': mark_safe(value),
'available_languages': mark_safe(self.get_available_languages()),
'strip_parameters': self.get_strip_parameters(),
'components_json': mark_safe(json.dumps(self.build_available_components()))}
return mark_safe(render_to_string(self.template_name, context))
def build_available_components(self):
components = []
templates = ComponentFinder().find()
for template in templates:
try:
t = json.loads(render_to_string('react_cms/react_components/{}'.format(template)), object_pairs_hook=OrderedDict)
except ValueError as e:
raise ValueError("Failed decoding JSON on react_cms/react_components/{}. {}".format(template, e))
components.append(self.prepare_component(t["info"]))
return components
def prepare_component(self, component):
if 'props' not in component:
component['props'] = {}
for editable_prop in component['editableProps']:
component['props'][editable_prop] = ''
return component
def get_available_languages(self):
languages = list(settings.LANGUAGES)
languages.pop(0) # First language is default
return [x[0] for x in languages]
def get_strip_parameters(self):
s = getattr(settings, 'REACT_CMS', {})
strip = s.get('STRIP_PARAMETERS_FROM_FILE_URL', False)
return 'true' if strip else 'false'
|
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 19 17:20:10 2017
@author: eduardo
"""
import funcs.patch_loader as pl
import tensorflow as tf
import funcs.utils as ut
import cnns.cnn_models as models
import numpy as np
import os
import funcs.image_processing as iproc
from matplotlib import pyplot as plt
import pickle as pkl
from shutil import copyfile
def print_s(string,file):
print(string)
print(string,file=file)
def train_loop(experiment_name, model_number, dataset_path, batch_norm=False, dropout=False):
"""
DEFINE PARAMETERS
"""
#experiment_name = "test_experiment"
#model_number = 1 # DEFINES IF THIS IS THE FIRST OR SECOND MODEL IN THE CASCADE
model = models.detector36(False, "model"+str(model_number), False, batch_norm=batch_norm ,dropout=dropout) # MODEL ARCHITECTURE
# LEARNING PARAMETERS
learning_rate = 0.0001
#training_iterations = int(5e3) # TRAINING ITERATIONS
training_iterations = int(5e3)
one_epoch_every = 1e2 # ITERATIONS PER EPOCH
number_of_epochs = int(training_iterations/one_epoch_every)+1
"""
PATH:
RESULTS
"""
results_path = "/home/eduardo/Results/"+experiment_name
if model_number == 1:
os.mkdir(results_path)
log_file = open(results_path+"/log"+str(model_number)+".txt","w") # LOG FILE
metrics_save_path = results_path+"/metrics"+str(model_number)+".npy"
save_weights_path = results_path+"/model"+str(model_number)
os.mkdir(save_weights_path)
load_weights_path = None
if model_number == 2:
load_weights_path = results_path+"/model1"
"""
DATASET
"""
#dataset_path = "/home/eduardo/dataset_name"
#if model_number == 2:
# dataset_path += "second"
evaluation_metric_index = 1 #DEFINES THE POSITION OF THE METRIC USED FOR COMPARISSON
evaluation_metric_objective = 1 #1 in case of Maximization and -1 in case of Minimization (ONLY POSITIVE VALUES)
number_of_evaluation_metrics = 4
metrics_array = np.zeros((number_of_epochs,number_of_evaluation_metrics*2+1))
max_evaluation_metric = -1e9
"""
CONFIGURE PATCH LOADER
"""
sess = tf.Session()
sess.run(tf.global_variables_initializer())
acts_list, loss_list, y_list = [],[],[]
#if load_weights_path:
#model.load(sess,load_weights_path)
epoch_counter = 0
for iteration in range(training_iterations):
# GET LOADED BATCH
batchx,batchy = pl.get_prepared_batch()
# START LOADING NEXT BATCH
pl.load_random_batch("train")
# TRAIN THE MODEL ON THE CURRENT BATCH
loss,acts = model.train(sess,batchx,batchy,learning_rate)
# APPEND ITERATION RESULTS IN THE LISTS
acts_list.append(acts)
loss_list.append(loss)
y_list.append(batchy)
if (iteration)%one_epoch_every == 0:
split_counter = pl.iterative_load_full_split("validation",0)
val_acts_list, val_loss_list, val_y_list = [],[],[]
while True:
val_batchx,val_batchy = pl.get_prepared_batch()
split_counter = pl.iterative_load_full_split("validation",split_counter)
val_loss,val_acts = model.test(sess,val_batchx,val_batchy)
val_acts_list.append(val_acts)
val_loss_list.append(val_loss)
val_y_list.append(val_batchy)
if split_counter == 0:
val_batchx,val_batchy = pl.get_prepared_batch()
val_loss,val_acts = model.test(sess,val_batchx,val_batchy)
val_acts_list.append(val_acts)
val_loss_list.append(val_loss)
val_y_list.append(val_batchy)
break
pl.load_random_batch("train")
# COMPUTE METRICS FOR THE TRAINING SET
acts_list = ut.concatenate_arrays(acts_list)[:,1]
loss_list = np.array(loss_list)
y_list = ut.concatenate_arrays(y_list)
metrics = ut.ut_metrics(acts_list, y_list,loss_list)
acts_list, loss_list, y_list = [],[],[]
# COMPUTE METRICS FOR THE VALIDATION SET
val_acts_list = ut.concatenate_arrays(val_acts_list)[:,1]
val_loss_list = np.array(val_loss_list)
val_y_list = ut.concatenate_arrays(val_y_list)
val_metrics = ut.ut_metrics(val_acts_list, val_y_list,val_loss_list)
# PRINT RESULTS
result_string = "Iter: "+str(iteration)
result_string += " | Train: "
for metric in metrics:
result_string += (metric[0] + ": " + str(metric[1]) + ", ")
# PRINT RESULTS
result_string += " | Validation: "
for metric in val_metrics:
result_string += (metric[0] + ": " + str(metric[1]) + ", ")
print_s(result_string,log_file)
# SAVE MODEL IF IT IS THE BEST
curr_evaluation_metric = evaluation_metric_objective * val_metrics[evaluation_metric_index][1]
if curr_evaluation_metric>max_evaluation_metric:
max_evaluation_metric = curr_evaluation_metric
model.save(sess,save_weights_path)
metrics_array[epoch_counter,0] = epoch_counter
i=1
for metric in metrics+val_metrics:
metrics_array[epoch_counter,i] = metric[1]
i+=1
epoch_counter+=1
log_file.close()
np.save(metrics_save_path,metrics_array[0:epoch_counter,:])
sess.close()
return metrics_array[0:epoch_counter,:]
import glob
def create_second_dataset(dataset_first,experiment_name,threshold=0.5):
print("Creating Second Dataset")
tf.reset_default_graph()
sess = tf.Session()
results_path = "/home/eduardo/Results/"+experiment_name
dataset_second = results_path+"/second_dataset/"
os.mkdir(dataset_second)
load_weights_path = results_path+"/model1"
model,model_full = load_model(sess,1,load_weights_path)
splits = ["train","validation","test"]
for split in splits:
os.makedirs(dataset_second+split+"/negative")
os.makedirs(dataset_second+split+"/positive")
print("Doing:",split)
neg_images = glob.glob(dataset_first+"/"+split+"/negative/*.npy")
pos_images = glob.glob(dataset_first+"/"+split+"/positive/*.npy")
bar = ut.progress_bar(len(neg_images)+len(pos_images))
for file in neg_images:
bar.tick()
img = np.load(file)
_,pred = model.test(sess,img[np.newaxis,:,:,np.newaxis],np.zeros((1,)))
if pred[0,1]>threshold:
copyfile(file,dataset_second+"/"+split+"/negative/"+os.path.basename(file))
for file in pos_images:
bar.tick()
copyfile(file,dataset_second+"/"+split+"/positive/"+os.path.basename(file))
copyfile(dataset_first+"/dataset_test",dataset_second+"/dataset_test")
print("FINISHED Creating Second Dataset")
"""
# TODO WITH MODEL NUMBER: IDEA -> Use recursion
def test_model(model_num, experiment_name, dataset_first,sigma=2,num_dets=10,thresh=0.5,sufix=""):
tf.reset_default_graph()
sess = tf.Session()
results_path = "/home/eduardo/Results/"+experiment_name
#os.mkdir(results_path+"/heatmaps"+str(model_num))
load_weights_path = results_path+"/model1"
model,model_full = load_model(sess,model_num,load_weights_path)
iDs = dataset_first.files_names.keys()
all_suspicions = dict()
bar = ut.progress_bar(len(iDs))
for iD in iDs: # TODO
bar.tick()
all_suspicions[iD] = list()
image = np.load(dataset_first.files_names[iD])
htmap = model_full.test(sess,image)
htmap = iproc.filter_img(htmap,sigma)
htmap = htmap*(htmap>thresh)
htmap = iproc.improved_non_maxima_supression(htmap)
#np.save(results_path+"/heatmaps"+str(model_num)+"/"+os.path.basename(dataset_first.files_names[iD]),htmap)
dets = iproc.detections(htmap,num_dets)
masks = []
masks_files = dataset_first.masks[iD]
for file in masks_files:
mask = np.load(file)
mask = augment_mask(mask)
masks.append(mask)
masks_hit = np.zeros(len(masks))
for det in dets:
correct_mask = inside_masks(det,masks,masks_hit)
if correct_mask!=-1:
if not masks_hit[correct_mask]:
all_suspicions[iD].append([*det,"TP"])
masks_hit[correct_mask]=1
else:
all_suspicions[iD].append([*det,"FP"])
for i in range(len(masks_hit)):
if masks_hit[i] == 0:
all_suspicions[iD].append([-1,-1,"FN"])
pkl.dump(all_suspicions,open(results_path+"/all_suspicions"+sufix,"wb"))
compute_score(all_suspicions,results_path,sufix)
sess.close()
return all_suspicions
"""
def create_pmaps(experiment_name, dataset_first):
#tf.reset_default_graph()
#sess = tf.Session()
results_path = "/home/eduardo/Results/"+experiment_name
#os.mkdir(results_path+"/pmaps")
#load_weights_path1 = results_path+"/model1"
#_,model_full1 = load_model(sess,1,load_weights_path1)
iDs = dataset_first.files_names.keys()
bar = ut.progress_bar(len(iDs))
for iD in iDs: # TODO
bar.tick()
#image = np.load(dataset_first.files_names[iD])
#pmap = model_full1.test(sess,image)
#np.save(results_path+"/pmaps"+"/"+str(iD),pmap)
masks = get_masks(dataset_first.masks[iD],add=False)
for i in range(len(masks)):
np.save(results_path+"/pmaps"+"/m"+str(iD)+"_"+str(i),masks[i])
#sess.close()
def test_model(experiment_name, dataset_first,sigma=1,num_dets=40,thresh=0.5, both_models = False):
tf.reset_default_graph()
sess = tf.Session()
results_path = "/home/eduardo/Results/"+experiment_name
load_weights_path1 = results_path+"/model1"
if both_models:
load_weights_path2 = results_path+"/model2"
_,model_full1 = load_model(sess,1,load_weights_path1)
if both_models:
model2,_ = load_model(sess,2,load_weights_path2)
iDs = dataset_first.files_names.keys()
sufix = ""
if both_models: sufix = "second"
all_suspicions = dict()
bar = ut.progress_bar(len(iDs))
for iD in iDs: # TODO
bar.tick()
all_suspicions[iD] = list()
image = np.load(dataset_first.files_names[iD])
detections = get_dets(sess, model_full1, image, sigma=sigma, thresh=thresh, num_dets=num_dets)
if both_models:
detections = reclassify_detections(sess,model2,image,detections)
for i in range(len(detections)):
plt.scatter(detections[i][0][1],detections[i][0][0],c="b")
plt.imshow(model_full1.test(sess,image))
plt.show()
masks = get_masks(dataset_first.masks[iD])
all_suspicions[iD] += get_suspicions(detections, masks)
pkl.dump(all_suspicions,open(results_path+"/all_suspicions"+sufix,"wb"))
compute_score(all_suspicions,results_path,sufix)
sess.close()
return all_suspicions
def reclassify_detections(sess,model,image,detections):
patches = np.zeros((len(detections),36,36,1))
image = iproc.all_pad(image, 20, "reflect")
counter = 0
for det in detections:
x,y = det[0]+20
patches[counter,:,:,0] = image[x-18:x+18,y-18:y+18]
counter+=1
_,preds = model.test(sess,patches,np.ones(len(detections)))
counter = 0
for det in detections:
detections[counter][1] = preds[counter,1]
counter+=1
return detections
def get_suspicions(detections,masks):
suspicions = []
masks_hit = np.zeros(len(masks))
for det in detections:
correct_mask = inside_masks(det,masks,masks_hit)
if correct_mask!=-1:
if not masks_hit[correct_mask]:
suspicions.append([*det,"TP"])
masks_hit[correct_mask]=1
else:
suspicions.append([*det,"FP"])
for i in range(len(masks_hit)):
if masks_hit[i] == 0:
suspicions.append([-1,-1,"FN"])
return suspicions
def get_dets(sess, model_full, image, sigma=0.8, thresh=-1, num_dets=40):
htmap = model_full.test(sess,image)
#htmap = iproc.filter_img(htmap,sigma)
htmap = htmap*(htmap>thresh)
htmap = iproc.improved_non_maxima_supression(htmap)
#np.save(results_path+"/heatmaps"+str(model_num)+"/"+os.path.basename(dataset_first.files_names[iD]),htmap)
dets = iproc.detections(htmap,num_dets)
return dets
def get_masks(masks_files,add=True):
masks = []
for file in masks_files:
mask = np.load(file)
if add:
mask = augment_mask(mask)
masks.append(mask)
return masks
from scipy.ndimage.measurements import center_of_mass as center_of_mass
def augment_mask(mask):
center = center_of_mass(mask)
mask[int(np.floor(center[0]))-9:int(np.ceil(center[0]))+9,int(np.floor(center[1]))-9:int(np.ceil(center[1]))+9] = True
#plt.imshow(mask)
#plt.show()
return mask
def compute_score(all_suspicions,results_path="",sufix=""):
num_of_masses = 0
num_of_images = 0
for image in all_suspicions.keys():
num_of_images+=1
for susp in all_suspicions[image]:
if susp[2] in ["TP","FN"]:
num_of_masses+=1
print("Working with:",num_of_masses," masks")
print("Working with:",num_of_images," images")
tp = np.zeros(num_of_masses)
fp = list()
counter=0
for image in all_suspicions.keys():
for susp in all_suspicions[image]:
if susp[2] == "TP":
tp[counter] = susp[1]
counter+=1
elif susp[2] == "FP":
fp.append(susp[1])
finalTP = np.stack((tp,np.ones(tp.shape)),axis=1)
fp = np.array(fp)
finalFP = np.stack((fp,np.zeros(fp.shape)),axis=1)
final = np.concatenate((finalTP,finalFP),axis = 0)
indexes = np.argsort(final[:,0])
final[:] = final[indexes[::-1]]
tpr_vec = np.cumsum(final[:,1])/num_of_masses
fpi_vec = np.cumsum(final[:,1]==0)/num_of_images
plt.scatter(fpi_vec,tpr_vec,s=0.1)
pkl.dump([fpi_vec,tpr_vec],open(results_path+"/fpi_tpr_vecs"+sufix,"wb"))
plt.savefig(results_path+"/Free_Roc_Curve"+sufix)
return final,fpi_vec,tpr_vec
def inside_masks(det,masks,masks_hit):
for i in range(masks_hit.shape[0]):
center = det[0]
mask = masks[i]
#plt.imshow(mask)
#plt.show()
#print(center)
if mask[center[0],center[1]]:
return i
return -1
def load_model(sess,model_num,load_weights_path):
print(load_weights_path)
model = models.detector36(False, "model"+str(model_num), False,False,False)
model.load(sess,load_weights_path)
model_full = models.detector36(True, "model"+str(model_num), True,False,False)
return model,model_full
#dataset = pkl.load(open("/home/eduardo/data_inbreast_40_deform_elas/dataset_test","rb"))
#experiment_name = "Batch_Dropout_exp_False_True"
#create_pmaps(experiment_name,dataset)
#data = pkl.load(open("/home/eduardo/data_inbreast_40_deform_elas/dataset_test","rb"))
#exp_name = "Batch_Dropout_exp_False_True"
#test_model(exp_name,data)
|
import json
import uuid
import networkx as nx
import redis
from solar import utils
from .traversal import states
r = redis.StrictRedis(host='10.0.0.2', port=6379, db=1)
def save_graph(name, graph):
# maybe it is possible to store part of information in AsyncResult backend
r.set('{}:nodes'.format(name), json.dumps(graph.node.items()))
r.set('{}:edges'.format(name), json.dumps(graph.edges(data=True)))
r.set('{}:attributes'.format(name), json.dumps(graph.graph))
def get_graph(name):
dg = nx.MultiDiGraph()
nodes = json.loads(r.get('{}:nodes'.format(name)))
edges = json.loads(r.get('{}:edges'.format(name)))
dg.graph = json.loads(r.get('{}:attributes'.format(name)))
dg.add_nodes_from(nodes)
dg.add_edges_from(edges)
return dg
get_plan = get_graph
def parse_plan(plan_data):
""" parses yaml definition and returns graph
"""
plan = utils.yaml_load(plan_data)
dg = nx.MultiDiGraph()
dg.graph['name'] = plan['name']
for task in plan['tasks']:
defaults = {
'status': 'PENDING',
'errmsg': None,
}
defaults.update(task['parameters'])
dg.add_node(
task['uid'], **defaults)
for v in task.get('before', ()):
dg.add_edge(task['uid'], v)
for u in task.get('after', ()):
dg.add_edge(u, task['uid'])
return dg
def create_plan_from_graph(dg, save=True):
dg.graph['uid'] = "{0}:{1}".format(dg.graph['name'], str(uuid.uuid4()))
if save:
save_graph(dg.graph['uid'], dg)
return dg
def show(uid):
dg = get_graph(uid)
result = {}
tasks = []
result['uid'] = dg.graph['uid']
result['name'] = dg.graph['name']
for n in nx.topological_sort(dg):
data = dg.node[n]
tasks.append(
{'uid': n,
'parameters': data,
'before': dg.successors(n),
'after': dg.predecessors(n)
})
result['tasks'] = tasks
return utils.yaml_dump(result)
def create_plan(plan_data, save=True):
"""
"""
dg = parse_plan(plan_data)
return create_plan_from_graph(dg, save=save)
def update_plan(uid, plan_data):
"""update preserves old status of tasks if they werent removed
"""
dg = parse_plan(plan_data)
old_dg = get_graph(uid)
dg.graph = old_dg.graph
for n in dg:
if n in old_dg:
dg.node[n]['status'] = old_dg.node[n]['status']
save_graph(uid, dg)
return uid
def reset(uid, state_list=None):
dg = get_graph(uid)
for n in dg:
if state_list is None or dg.node[n]['status'] in state_list:
dg.node[n]['status'] = states.PENDING.name
save_graph(uid, dg)
def reset_filtered(uid):
reset(uid, state_list=[states.SKIPPED.name, states.NOOP.name])
def report_topo(uid):
dg = get_graph(uid)
report = []
for task in nx.topological_sort(dg):
report.append([task, dg.node[task]['status'], dg.node[task]['errmsg']])
return report
|
from __future__ import print_function
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
from keras.layers import LSTM
from keras.optimizers import RMSprop
from keras.utils.data_utils import get_file
import numpy as np
import random
import sys
import h5py
from utils import *
import os
import codecs
print('Cargando dataset...')
path = "dataseth5/con-dict.h5"
with h5py.File(path,'r') as hf:
text = str(hf.get('dataset')[0]).decode("unicode_escape")
print('corpus length:', len(text))
chars = sorted(list(set(text)))
print('total chars:', len(chars))
char_indices = dict((c, i) for i, c in enumerate(chars))
indices_char = dict((i, c) for i, c in enumerate(chars))
print('Creando oraciones...')
# cut the text in semi-redundant sequences of maxlen characters
maxlen = 40
step = 3
sentences = []
next_chars = []
for i in range(0, len(text) - maxlen, step):
sentences.append(text[i: i + maxlen])
next_chars.append(text[i + maxlen])
cut=np.random.randint(1, 39)
sentences.append(' '*cut+text[i+cut: i + maxlen])
next_chars.append(text[i + maxlen])
print('nb sequences:', len(sentences))
print('Vectorizando...')
X = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool)
y = np.zeros((len(sentences), len(chars)), dtype=np.bool)
for i, sentence in enumerate(sentences):
for t, char in enumerate(sentence):
X[i, t, char_indices[char]] = 1
y[i, char_indices[next_chars[i]]] = 1
# build the model: a single LSTM
print('Creando modelo...')
model = Sequential()
model.add(LSTM(128, input_shape=(maxlen, len(chars))))
model.add(Dense(len(chars)))
model.add(Activation('softmax'))
optimizer = RMSprop(lr=0.01)
print('Compilando...')
model.compile(loss='categorical_crossentropy', optimizer=optimizer)
def sample(preds, temperature=1.0):
# helper function to sample an index from a probability array
preds = np.asarray(preds).astype('float64')
preds = np.log(preds) / temperature
exp_preds = np.exp(preds)
preds = exp_preds / np.sum(exp_preds)
probas = np.random.multinomial(1, preds, 1)
return np.argmax(probas)
print('Entrenando...')
name=NameGen(os.path.basename(sys.argv[0]))
modelfile = name.get_model_file('best-model.h5')
# train the model, output generated text after each iteration
best_loss = None
for iteration in range(1, 25):
print()
print('-' * 50)
print('Iteration', iteration)
history = model.fit(X, y, batch_size=128, nb_epoch=1)
if best_loss is None or best_loss>history.history['loss']:
print('Guardando modelo en {}'.format(modelfile))
best_loss = history.history['loss']
model.save(modelfile)
start_index = random.randint(0, len(text) - maxlen - 1)
for diversity in [0.2, 0.5, 1.0, 1.2]:
print()
print('----- diversity:', diversity)
generated = ''
sentence = text[start_index: start_index + maxlen]
generated += sentence
print('----- Generating with seed: "' + sentence + '"')
sys.stdout.write(generated)
for i in range(400):
x = np.zeros((1, maxlen, len(chars)))
for t, char in enumerate(sentence):
x[0, t, char_indices[char]] = 1.
preds = model.predict(x, verbose=0)[0]
next_index = sample(preds, diversity)
next_char = indices_char[next_index]
generated += next_char
sentence = sentence[1:] + next_char
sys.stdout.write(next_char)
sys.stdout.flush()
print()
|
import re
def add_value(my_bots, bot_i, val_n):
if bot_i in my_bots:
my_bots[bot_i].append(val_n)
else:
my_bots[bot_i] = [val_n]
def transfer_chips(my_bots, bot_id):
# note: does not cater to both high and low going to same bot that currently holds one chip
for key, value in my_bot_instr[bot_id].items():
if value != 'OUTPUT' and has_max_chips(my_bots, value):
transfer_chips(my_bots, value)
# now the recipients will have < 2 chips
tmp = 0
for key, value in my_bot_instr[bot_id].items():
if key == 'LOW':
tmp = min(my_bots[bot_id])
else:
tmp = max(my_bots[bot_id])
if value != 'OUTPUT':
add_value(my_bots, value, tmp)
my_bots[bot_id].remove(tmp)
def has_max_chips(my_bots, bot_id):
return (bot_id in my_bots and (len(my_bots[bot_id]) > 1))
with open('aoc10-input.txt', 'r') as infile:
# format: value 5 goes to bot 2
add_regex = re.compile(r"value ([0-9]+) goes to bot ([0-9]+)")
# format: bot 2 gives low to bot 1 and high to bot 0
move_regex = re.compile(r"bot ([0-9]+) gives low to (bot|output) ([0-9]+) and high to (bot|output) ([0-9]+)")
# x = for each both ID, a list of chip IDs it holds
my_bots = {}
# x = for each bot ID, a dict of key, value = LOW/HIGH, next bot ID
my_bot_instr = {}
for line in infile:
add_result = add_regex.match(line)
move_result = move_regex.match(line)
if add_result:
my_value = int(add_result.group(1))
bot_target = int(add_result.group(2))
add_value(my_bots, bot_target, my_value)
elif move_result:
bot_src = int(move_result.group(1))
instr_low = move_result.group(2)
bot_low = int(move_result.group(3))
instr_high = move_result.group(4)
bot_high = int(move_result.group(5))
my_bot_instr[bot_src] = {}
for i in ((instr_low, bot_low, 'LOW'), (instr_high, bot_high, 'HIGH')):
if i[0] == 'bot':
my_bot_instr.setdefault(bot_src,[]).update({i[2]: i[1]})
elif i[0] == 'output':
my_bot_instr.setdefault(bot_src,[]).update({i[2]: 'OUTPUT'})
result = False
while not result:
# find bot with two chips and pass those on
for key, value in my_bots.items():
if len(value) > 1:
transfer_chips(my_bots, key)
break
for key, value in my_bots.items():
if 17 in value and 61 in value:
print(key)
result = True
|
# Copyright 2021 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Timesketch API search template object."""
import logging
from . import error
from . import resource
from . import search
logger = logging.getLogger('timesketch_api.searchtemplate')
class SearchTemplate(resource.BaseResource):
"""Search template object. TEST e2e"""
def __init__(self, api):
"""Initialize the search template object."""
super().__init__(api, 'searchtemplate/')
self._description = ''
self._name = ''
self._resource_id = None
self._search_id = None
self._sketch_id = None
@property
def description(self):
"""Property that returns the template description."""
if self._description:
return self._description
if not self._resource_id:
logger.error('No resource ID, have you loaded the template yet?')
raise ValueError('Unable to get a name, not loaded yet.')
data = self.lazyload_data()
objects = data.get('objects')
if not objects:
return 'No description'
self._description = objects[0].get('description', 'N/A')
return self._description
def delete(self):
"""Deletes the saved graph from the store."""
if not self._resource_id:
raise ValueError(
'Unable to delete the search template, since the template '
'does not seem to be saved, which is required.')
resource_url = (
f'{self.api.api_root}/searchtemplate/{self._resource_id}/')
response = self.api.session.delete(resource_url)
return error.check_return_status(response, logger)
def from_saved(self, template_id, sketch_id=0):
"""Initialize the search template from a saved template, by ID value.
Args:
template_id: integer value for the saved search template.
sketch_id: optional integer value for a sketch ID. If not
provided, an attempt is made to figure it out.
Raises:
ValueError: If issues came up during processing.
"""
self._resource_id = template_id
self.resource_uri = f'searchtemplate/{self._resource_id}/'
if sketch_id:
self._sketch_id = sketch_id
else:
data = self.lazyload_data(refresh_cache=True)
meta = data.get('meta', {})
sketch_ids = meta.get('sketch_ids', [])
if len(sketch_ids) > 1:
sketch_string = ', '.join(sketch_ids)
raise ValueError(
'Search template has too many attached saved searches, '
'please pick one from: {0:s}'.format(sketch_string))
self._sketch_id = sketch_ids[0]
def from_search_object(self, search_obj):
"""Initialize template from a search object.
Args:
search_obj (search.Search): a search object.
"""
self._search_id = search_obj.id
self._sketch_id = search_obj.sketch.id
response = self.api.fetch_resource_data('searchtemplate/')
meta = response.get('meta', {})
template_id = 0
for data in meta.get('collection', []):
if data.get('search_id') == self._search_id:
template_id = data.get('template_id', 0)
if not template_id:
return
self._resource_id = template_id
self.resource_uri = f'searchtemplate/{self._resource_id}/'
@property
def id(self):
"""Property that returns back the search template ID."""
return self._resource_id
@property
def name(self):
"""Property that returns the template name."""
if self._name:
return self._name
if not self._resource_id:
logger.error('No resource ID, have you loaded the template yet?')
raise ValueError('Unable to get a name, not loaded yet.')
data = self.lazyload_data()
objects = data.get('objects')
if not objects:
return 'No name'
self._name = objects[0].get('name', 'N/A')
return self._name
def set_sketch(self, sketch=None, sketch_id=None):
"""Set the sketch for the search template.
Args:
sketch (sketch.Sketch): an optional sketch object to use as the
sketch object for the search template.
sketch_id (int): an optional sketch ID to use as the sketch ID
for the search template.
Raises:
ValueError: If neither a sketch nor a sketch ID is set.
"""
if not sketch and not sketch_id:
raise ValueError('Either sketch or sketch ID needs to be set.')
if sketch:
self._sketch_id = sketch
elif isinstance(sketch_id, int):
self._sketch_id = sketch_id
else:
raise ValueError(
'Sketch needs to be set, or an integer value for '
'a sketch ID.')
def save(self):
"""Save the search template."""
if self._resource_id:
raise ValueError(
'The template has already been saved, ATM updates to an '
'existing template are not yet supported.')
if not self._search_id:
raise ValueError(
'Unable to save the search template since the identification '
'value of the saved search is not known. The object needs '
'to be initialized from a previously saved search.')
data = {
'search_id': self._search_id,
}
resource_url = f'{self.api.api_root}/searchtemplate/'
response = self.api.session.post(resource_url, json=data)
status = error.check_return_status(response, logger)
if not status:
error.error_message(
response, 'Unable to save search as a template',
error=RuntimeError)
response_json = error.get_response_json(response, logger)
template_dict = response_json.get('objects', [{}])[0]
self._resource_id = template_dict.get('id', 0)
self.resource_uri = f'searchtemplate/{self._resource_id}/'
return f'Saved search as a template to ID: {self.id}'
def to_search(self):
"""Returns a search object from a template."""
if not self._resource_id:
raise ValueError(
'Unable to get a search object unless it is tied to a '
'template.')
if not self._sketch_id:
raise ValueError(
'Unable to get a search object unless it is tied to '
'a sketch.')
data = self.lazyload_data(refresh_cache=True)
objects = data.get('objects')
if not objects:
raise ValueError(
'Unable to get search object, issue with retrieving '
'template data.')
template_dict = objects[0]
sketch = self.api.get_sketch(self._sketch_id)
search_obj = search.Search(sketch=sketch)
search_obj.from_manual(
query_string=template_dict.get('query_string'),
query_dsl=template_dict.get('query_dsl'),
query_filter=template_dict.get('query_filter'))
search_obj.name = template_dict.get('name', 'No Name')
search_obj.description = template_dict.get(
'description', 'No Description')
return search_obj
|
import json
from pathlib import Path
from nltk.tree import ParentedTree
from nose import SkipTest
from nose.tools import eq_
from rstfinder.discourse_parsing import Parser
from rstfinder.extract_actions_from_trees import extract_parse_actions
MY_DIR = Path(__file__).parent
def test_extract_parse_actions():
"""Check that parse actions are extracted as expected."""
# the following tree represents a sentence like:
# "John said that if Bob bought this excellent book,
# then before the end of next week Bob would finish it,
# and therefore he would be happy."
tree = ParentedTree.fromstring("""(ROOT
(satellite:attribution (text 0))
(nucleus:span
(satellite:condition (text 1))
(nucleus:span
(nucleus:span
(nucleus:same-unit (text 2))
(nucleus:same-unit
(satellite:temporal (text 3))
(nucleus:span (text 4))))
(satellite:conclusion (text 5)))))
""")
actions = extract_parse_actions(tree)
num_shifts = len([x for x in actions if x.type == 'S'])
eq_(num_shifts, 6)
eq_(actions[0].type, 'S')
eq_(actions[1].type, 'U')
eq_(actions[1].label, "satellite:attribution")
eq_(actions[2].type, 'S')
def test_reconstruct_training_examples():
"""Check extracted actions for entire training data."""
# go through the training data and make sure
# that the actions extracted from the trees can be used to
# reconstruct those trees from a list of EDUs
# check if the training data file exists, otherwise skip test
file_path = Path('rst_discourse_tb_edus_TRAINING_TRAIN.json')
if not file_path.exists():
raise SkipTest("training data JSON file not found")
# read in the training data file
with open(file_path) as train_data_file:
data = json.load(train_data_file)
# instantiate the parser
rst_parser = Parser(max_acts=1, max_states=1, n_best=1)
# iterate over each document in the training data
for doc_dict in data:
# get the original RST tree
original_tree = ParentedTree.fromstring(doc_dict['rst_tree'])
# extract the parser actions from this tree
actions = extract_parse_actions(original_tree)
# reconstruct the tree from these actions using the parser
reconstructed_tree = next(rst_parser.parse(doc_dict,
gold_actions=actions,
make_features=False))['tree']
eq_(reconstructed_tree, original_tree)
def test_parse_single_edu():
"""Test that parsing a single EDU works as expected."""
# load in an input file with a single EDU
input_file = MY_DIR / "data" / "single_edu_parse_input.json"
doc_dict = json.load(open(input_file, 'r'))
# instantiate the parser
rst_parser = Parser(max_acts=1, max_states=1, n_best=1)
rst_parser.load_model(str(MY_DIR / "models"))
# make sure that we have a very simple RST tree as expected
tree = list(rst_parser.parse(doc_dict))[0]['tree']
eq_(tree.root().label(), 'ROOT')
eq_(len(tree.leaves()), 1)
subtrees = list(tree.subtrees())
eq_(len(subtrees), 2)
|
from django import forms
from models import MailUser
class PasswordChangeForm(forms.Form):
username = forms.CharField(max_length=50)
old_password = forms.CharField(max_length=50, widget=forms.PasswordInput)
new_password = forms.CharField(max_length=50, widget=forms.PasswordInput)
confirm_new_password = forms.CharField(max_length=50, widget=forms.PasswordInput)
def clean(self):
try:
mail_user = MailUser.objects.select_related().get(internal_username=self.cleaned_data['username'])
except (MailUser.DoesNotExist, MailUser.MultipleObjectsReturned):
raise forms.ValidationError("Incorrect username or old password")
if (not mail_user.disabled) and mail_user.authenticate(self.cleaned_data['old_password']):
self.cleaned_data['user'] = mail_user
else:
raise forms.ValidationError("Incorrect username or old password")
if self.cleaned_data['new_password'] != self.cleaned_data['confirm_new_password']:
raise forms.ValidationError("New password and confirmation don't match")
return self.cleaned_data
|
import numpy as np
import pyflux as pf
# Generate some random data
noise = np.random.normal(0,1,200)
data = np.zeros(200)
for i in range(1,len(data)):
data[i] = 0.9*data[i-1] + noise[i]
countdata = np.random.poisson(3,200)
exponentialdata = np.random.exponential(3,200)
def test_cauchy_no_terms():
"""
Tests an GAS model with no AR or SC terms, and that
the latent variable list length is correct, and that the estimated
latent variables are not nan
"""
model = pf.GAS(data=data, ar=0, sc=0, family=pf.Cauchy())
x = model.fit()
assert(len(model.latent_variables.z_list) == 2)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_couple_terms():
"""
Tests an GAS model with 1 AR and 1 SC term and that
the latent variable list length is correct, and that the estimated
latent variables are not nan
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit()
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_couple_terms_integ():
"""
Tests an GAS model with 1 AR and 1 SC term, integrated once, and that
the latent variable list length is correct, and that the estimated
latent variables are not nan
"""
model = pf.GAS(data=data, ar=1, sc=1, integ=1, family=pf.Cauchy())
x = model.fit()
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_bbvi():
"""
Tests an GAS model estimated with BBVI and that the length of the latent variable
list is correct, and that the estimated latent variables are not nan
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI',iterations=100)
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_bbvi_mini_batch():
"""
Tests an ARIMA model estimated with BBVI and that the length of the latent variable
list is correct, and that the estimated latent variables are not nan
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI',iterations=100, mini_batch=32)
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_bbvi_elbo():
"""
Tests that the ELBO increases
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI',iterations=150, record_elbo=True, map_start=False)
assert(x.elbo_records[-1]>x.elbo_records[0])
def test_cauchy_bbvi_mini_batch_elbo():
"""
Tests that the ELBO increases
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI',iterations=100, mini_batch=32, record_elbo=True)
assert(x.elbo_records[-1]>x.elbo_records[0])
def test_cauchy_mh():
"""
Tests an GAS model estimated with Metropolis-Hastings and that the length of the
latent variable list is correct, and that the estimated latent variables are not nan
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('M-H',nsims=300)
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_laplace():
"""
Tests an GAS model estimated with Laplace approximation and that the length of the
latent variable list is correct, and that the estimated latent variables are not nan
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('Laplace')
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_pml():
"""
Tests a PML model estimated with Laplace approximation and that the length of the
latent variable list is correct, and that the estimated latent variables are not nan
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('PML')
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_cauchy_predict_length():
"""
Tests that the prediction dataframe length is equal to the number of steps h
"""
model = pf.GAS(data=data, ar=2, sc=2, family=pf.Cauchy())
x = model.fit()
x.summary()
assert(model.predict(h=5).shape[0] == 5)
def test_cauchy_predict_is_length():
"""
Tests that the prediction IS dataframe length is equal to the number of steps h
"""
model = pf.GAS(data=data, ar=2, sc=2, family=pf.Cauchy())
x = model.fit()
assert(model.predict_is(h=5).shape[0] == 5)
def test_cauchy_predict_nans():
"""
Tests that the predictions are not nans
"""
model = pf.GAS(data=data, ar=2, sc=2, family=pf.Cauchy())
x = model.fit()
x.summary()
assert(len(model.predict(h=5).values[np.isnan(model.predict(h=5).values)]) == 0)
def test_cauchy_predict_is_nans():
"""
Tests that the in-sample predictions are not nans
"""
model = pf.GAS(data=data, ar=2, sc=2, family=pf.Cauchy())
x = model.fit()
x.summary()
assert(len(model.predict_is(h=5).values[np.isnan(model.predict_is(h=5).values)]) == 0)
def test_cauchy_predict_nonconstant():
"""
We should not really have predictions that are constant (should be some difference)...
This captures bugs with the predict function not iterating forward
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit()
predictions = model.predict(h=10, intervals=False)
assert(not np.all(predictions.values==predictions.values[0]))
def test_cauchy_predict_is_nonconstant():
"""
We should not really have predictions that are constant (should be some difference)...
This captures bugs with the predict function not iterating forward
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit()
predictions = model.predict_is(h=10, intervals=False)
assert(not np.all(predictions.values==predictions.values[0]))
def test_cauchy_predict_intervals():
"""
Tests prediction intervals are ordered correctly
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit()
predictions = model.predict(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
def test_cauchy_predict_is_intervals():
"""
Tests prediction intervals are ordered correctly
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit()
predictions = model.predict_is(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
def test_cauchy_predict_intervals_bbvi():
"""
Tests prediction intervals are ordered correctly
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI', iterations=100)
predictions = model.predict(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
def test_cauchy_predict_is_intervals_bbvi():
"""
Tests prediction intervals are ordered correctly
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI', iterations=100)
predictions = model.predict_is(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
def test_cauchy_predict_intervals_mh():
"""
Tests prediction intervals are ordered correctly
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('M-H', nsims=400)
predictions = model.predict(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
def test_cauchy_predict_is_intervals_mh():
"""
Tests prediction intervals are ordered correctly
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('M-H', nsims=400)
predictions = model.predict_is(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
def test_cauchy_sample_model():
"""
Tests sampling function
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI', iterations=100)
sample = model.sample(nsims=100)
assert(sample.shape[0]==100)
assert(sample.shape[1]==len(data)-1)
def test_cauchy_ppc():
"""
Tests PPC value
"""
model = pf.GAS(data=data, ar=1, sc=1, family=pf.Cauchy())
x = model.fit('BBVI', iterations=100)
p_value = model.ppc()
assert(0.0 <= p_value <= 1.0)
|
from __future__ import absolute_import
from __future__ import print_function
from .BlockScan import BlockScan
from amitools.fs.FSString import FSString
from amitools.fs.FileName import FileName
from amitools.fs.validate.Log import Log
import amitools.fs.DosType as DosType
class DirChainEntry:
"""entry of the hash chain"""
def __init__(self, blk_info):
self.blk_info = blk_info
self.parent_ok = False
self.fn_hash_ok = False
self.valid = False
self.end = False
self.orphaned = False
self.sub = None
def __str__(self):
l = []
if self.parent_ok:
l.append("parent_ok")
if self.fn_hash_ok:
l.append("fn_hash_ok")
if self.valid:
l.append("valid")
if self.end:
l.append("end")
if self.orphaned:
l.append("orphaned")
return "[DCE @%d '%s': %s]" % \
(self.blk_info.blk_num, self.blk_info.name, " ".join(l))
class DirChain:
"""representing a chain of the hashtable in a directory"""
def __init__(self, hash_val):
self.hash_val = hash_val
self.chain = []
def add(self, dce):
self.chain.append(dce)
def get_entries(self):
return self.chain
def __str__(self):
return "{DirChain +%d: #%d}" % (self.hash_val, len(self.chain))
class DirInfo:
"""information structure on a directory"""
def __init__(self, blk_info):
self.blk_info = blk_info
self.chains = {}
self.children = []
def add(self, dc):
self.chains[dc.hash_val] = dc
def add_child(self, c):
self.children.append(c)
def get(self, hash_val):
if hash_val in self.chains:
return self.chains[hash_val]
else:
return None
def get_chains(self):
return self.chains
def __str__(self):
bi = self.blk_info
blk_num = bi.blk_num
name = bi.name
parent_blk = bi.parent_blk
return "<DirInfo @%d '%s' #%d parent:%d child:#%d>" % (blk_num, name, len(self.chains), parent_blk, len(self.children))
class DirScan:
"""directory tree scanner"""
def __init__(self, block_scan, log):
self.log = log
self.block_scan = block_scan
self.root_di = None
self.intl = DosType.is_intl(block_scan.dos_type)
self.files = []
self.dirs = []
def scan_tree(self, root_blk_num, progress=None):
"""scan the root tree"""
# get root block info
root_bi = self.block_scan.get_block(root_blk_num)
if root_bi == None:
self.log.msg(Log.ERROR,"Root block not found?!",root_blk_num)
return None
# do tree scan
if progress != None:
progress.begin("dir")
self.root_di = self.scan_dir(root_bi, progress)
if progress != None:
progress.end()
return self.root_di
def scan_dir(self, dir_bi, progress):
"""check a directory by scanning through the hash table entries and follow the chains
Returns (all_chains_ok, dir_obj)
"""
# create new dir info
di = DirInfo(dir_bi)
self.dirs.append(di)
# run through hash_table of directory and build chains
chains = {}
hash_val = 0
for blk_num in dir_bi.hash_table:
if blk_num != 0:
# build chain
chain = DirChain(hash_val)
self.build_chain(chain, dir_bi, blk_num, progress)
di.add(chain)
hash_val += 1
return di
def build_chain(self, chain, dir_blk_info, blk_num, progress):
"""build a block chain"""
dir_blk_num = dir_blk_info.blk_num
dir_name = dir_blk_info.name
hash_val = chain.hash_val
# make sure entry block is first used
block_used = self.block_scan.is_block_available(blk_num)
# get entry block
blk_info = self.block_scan.read_block(blk_num)
# create dir chain entry
dce = DirChainEntry(blk_info)
chain.add(dce)
# account
if progress != None:
progress.add()
# block already used?
if block_used:
self.log.msg(Log.ERROR, "dir block already used in chain #%d of dir '%s (%d)" % (hash_val, dir_name, dir_blk_num), blk_num)
dce.end = True
return
# self reference?
if blk_num == dir_blk_num:
self.log.msg(Log.ERROR, "dir block in its own chain #%d of dir '%s' (%d)" % (hash_val, dir_name, dir_blk_num), blk_num)
dce.end = True
return
# not a block in range
if blk_info == None:
self.log.msg(Log.ERROR, "out-of-range block terminates chain #%d of dir '%s' (%d)" % (hash_val, dir_name, dir_blk_num), blk_num)
dce.end = True
return
# check type of entry block
b_type = blk_info.blk_type
if b_type not in (BlockScan.BT_DIR, BlockScan.BT_FILE_HDR):
self.log.msg(Log.ERROR, "invalid block terminates chain #%d of dir '%s' (%d)" % (hash_val, dir_name, dir_blk_num), blk_num)
dce.end = True
return
# check referenceed block type in chain
blk_type = blk_info.blk_type
if blk_type in (BlockScan.BT_ROOT, BlockScan.BT_FILE_LIST, BlockScan.BT_FILE_DATA):
self.log.msg(Log.ERROR, "invalid block type %d terminates chain #%d of dir '%s' (%d)" % (blk_type, hash_val, dir_name, dir_blk_num), blk_num)
dce.end = True
return
# all following are ok
dce.valid = True
# check parent of block
name = blk_info.name
dce.parent_ok = (blk_info.parent_blk == dir_blk_num)
if not dce.parent_ok:
self.log.msg(Log.ERROR, "invalid parent in '%s' chain #%d of dir '%s' (%d)" % (name, hash_val, dir_name, dir_blk_num), blk_num)
# check name hash
fn = FileName(name, self.intl)
fn_hash = fn.hash()
dce.fn_hash_ok = (fn_hash == hash_val)
if not dce.fn_hash_ok:
self.log.msg(Log.ERROR, "invalid name hash in '%s' chain #%d of dir '%s' (%d)" % (name, hash_val, dir_name, dir_blk_num), blk_num)
# recurse into dir?
if blk_type == BlockScan.BT_DIR:
dce.sub = self.scan_dir(blk_info, progress)
elif blk_type == BlockScan.BT_FILE_HDR:
self.files.append(dce)
# check next block in chain
next_blk = blk_info.next_blk
if next_blk != 0:
self.build_chain(chain, dir_blk_info, next_blk, progress)
else:
dce.end = True
def get_all_file_hdr_blk_infos(self):
"""return all file chain entries"""
result = []
for f in self.files:
result.append(f.blk_info)
return result
def get_all_dir_infos(self):
"""return all dir infos"""
return self.dirs
def dump(self):
"""dump whole dir info structure"""
self.dump_dir_info(self.root_di, 0)
def dump_dir_info(self, di, indent):
"""dump a single dir info structure and its sub dirs"""
istr = " " * indent
print(istr, di)
for hash_value in sorted(di.get_chains().keys()):
dc = di.get(hash_value)
print(istr, " ", dc)
for dce in dc.get_entries():
print(istr, " ", dce)
sub = dce.sub
if sub != None and dce.blk_info.blk_type == BlockScan.BT_DIR:
self.dump_dir_info(sub, indent+1)
|
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
Compute semantic similarities between GO terms. Borrowed from book chapter from
Alex Warwick Vesztrocy and Christophe Dessimoz (thanks). For details, please
check out:
notebooks/semantic_similarity.ipynb
"""
from __future__ import print_function
import sys
from collections import Counter
from collections import defaultdict
from goatools.godag.consts import NAMESPACE2GO
from goatools.godag.consts import NAMESPACE2NS
from goatools.godag.go_tasks import get_go2ancestors
from goatools.gosubdag.gosubdag import GoSubDag
from goatools.godag.relationship_combos import RelationshipCombos
from goatools.anno.update_association import clean_anno
from goatools.utils import get_b2aset
class TermCounts:
'''
TermCounts counts the term counts for each
'''
# pylint: disable=too-many-instance-attributes
def __init__(self, go2obj, annots, relationships=None, **kws):
'''
Initialise the counts and
'''
_prt = kws.get('prt')
# Backup
self.go2obj = go2obj # Full GODag
self.annots, go_alts = clean_anno(annots, go2obj, _prt)[:2]
# Genes annotated to all associated GO, including inherited up ancestors'
_relationship_set = RelationshipCombos(go2obj).get_set(relationships)
self.go2genes = self._init_go2genes(_relationship_set, go2obj)
self.gene2gos = get_b2aset(self.go2genes)
# Annotation main GO IDs (prefer main id to alt_id)
self.goids = set(self.go2genes.keys())
self.gocnts = Counter({go:len(geneset) for go, geneset in self.go2genes.items()})
# Get total count for each branch: BP MF CC
self.aspect_counts = {
'biological_process': self.gocnts.get(NAMESPACE2GO['biological_process'], 0),
'molecular_function': self.gocnts.get(NAMESPACE2GO['molecular_function'], 0),
'cellular_component': self.gocnts.get(NAMESPACE2GO['cellular_component'], 0)}
self._init_add_goid_alt(go_alts)
self.gosubdag = GoSubDag(
set(self.gocnts.keys()),
go2obj,
tcntobj=self,
relationships=_relationship_set,
prt=None)
if _prt:
self.prt_objdesc(_prt)
def get_annotations_reversed(self):
"""Return go2geneset for all GO IDs explicitly annotated to a gene"""
return set.union(*get_b2aset(self.annots))
def _init_go2genes(self, relationship_set, godag):
'''
Fills in the genes annotated to each GO, including ancestors
Due to the ontology structure, gene products annotated to
a GO Terma are also annotated to all ancestors.
'''
go2geneset = defaultdict(set)
go2up = get_go2ancestors(set(godag.values()), relationship_set)
# Fill go-geneset dict with GO IDs in annotations and their corresponding counts
for geneid, goids_anno in self.annots.items():
# Make a union of all the terms for a gene, if term parents are
# propagated but they won't get double-counted for the gene
allterms = set()
for goid_main in goids_anno:
allterms.add(goid_main)
if goid_main in go2up:
allterms.update(go2up[goid_main])
# Add 1 for each GO annotated to this gene product
for ancestor in allterms:
go2geneset[ancestor].add(geneid)
return dict(go2geneset)
def _init_add_goid_alt(self, not_main):
'''
Add alternate GO IDs to term counts. Report GO IDs not found in GO DAG.
'''
if not not_main:
return
for go_id in not_main:
if go_id in self.go2obj:
goid_main = self.go2obj[go_id].item_id
self.gocnts[go_id] = self.gocnts[goid_main]
self.go2genes[go_id] = self.go2genes[goid_main]
def get_count(self, go_id):
'''
Returns the count of that GO term observed in the annotations.
'''
return self.gocnts[go_id]
def get_total_count(self, aspect):
'''
Gets the total count that's been precomputed.
'''
return self.aspect_counts[aspect]
def get_term_freq(self, go_id):
'''
Returns the frequency at which a particular GO term has
been observed in the annotations.
'''
num_ns = float(self.get_total_count(self.go2obj[go_id].namespace))
return float(self.get_count(go_id))/num_ns if num_ns != 0 else 0
def get_gosubdag_all(self, prt=sys.stdout):
'''
Get GO DAG subset include descendants which are not included in the annotations
'''
goids = set()
for gos in self.gosubdag.rcntobj.go2descendants.values():
goids.update(gos)
return GoSubDag(goids, self.go2obj, self.gosubdag.relationships, tcntobj=self, prt=prt)
def prt_objdesc(self, prt=sys.stdout):
"""Print TermCount object description"""
ns_tot = sorted(self.aspect_counts.items())
cnts = ['{NS}({N:,})'.format(NS=NAMESPACE2NS[ns], N=n) for ns, n in ns_tot if n != 0]
go_msg = "TermCounts {CNT}".format(CNT=' '.join(cnts))
prt.write('{GO_MSG} {N:,} genes\n'.format(GO_MSG=go_msg, N=len(self.gene2gos)))
self.gosubdag.prt_objdesc(prt, go_msg)
def get_info_content(go_id, termcounts):
'''
Retrieve the information content of a GO term.
'''
ntd = termcounts.gosubdag.go2nt.get(go_id)
return ntd.tinfo if ntd else 0.0
def resnik_sim(go_id1, go_id2, godag, termcounts):
'''
Computes Resnik's similarity measure.
'''
goterm1 = godag[go_id1]
goterm2 = godag[go_id2]
if goterm1.namespace == goterm2.namespace:
msca_goid = deepest_common_ancestor([go_id1, go_id2], godag)
return get_info_content(msca_goid, termcounts)
return None
def lin_sim(goid1, goid2, godag, termcnts, dfltval=None):
'''
Computes Lin's similarity measure.
'''
sim_r = resnik_sim(goid1, goid2, godag, termcnts)
return lin_sim_calc(goid1, goid2, sim_r, termcnts, dfltval)
def lin_sim_calc(goid1, goid2, sim_r, termcnts, dfltval=None):
'''
Computes Lin's similarity measure using pre-calculated Resnik's similarities.
'''
# If goid1 and goid2 are in the same namespace
if sim_r is not None:
tinfo1 = get_info_content(goid1, termcnts)
tinfo2 = get_info_content(goid2, termcnts)
info = tinfo1 + tinfo2
# Both GO IDs must be annotated
if tinfo1 != 0.0 and tinfo2 != 0.0 and info != 0:
return (2*sim_r)/info
if termcnts.go2obj[goid1].item_id == termcnts.go2obj[goid2].item_id:
return 1.0
# The GOs are separated by the root term, so are not similar
if sim_r == 0.0:
return 0.0
return dfltval
def common_parent_go_ids(goids, godag):
'''
This function finds the common ancestors in the GO
tree of the list of goids in the input.
'''
# Find main GO ID candidates from first main or alt GO ID
rec = godag[goids[0]]
candidates = rec.get_all_parents()
candidates.update({rec.item_id})
# Find intersection with second to nth GO ID
for goid in goids[1:]:
rec = godag[goid]
parents = rec.get_all_parents()
parents.update({rec.item_id})
# Find the intersection with the candidates, and update.
candidates.intersection_update(parents)
return candidates
def deepest_common_ancestor(goterms, godag):
'''
This function gets the nearest common ancestor
using the above function.
Only returns single most specific - assumes unique exists.
'''
# Take the element at maximum depth.
return max(common_parent_go_ids(goterms, godag), key=lambda t: godag[t].depth)
def min_branch_length(go_id1, go_id2, godag, branch_dist):
'''
Finds the minimum branch length between two terms in the GO DAG.
'''
# First get the deepest common ancestor
goterm1 = godag[go_id1]
goterm2 = godag[go_id2]
if goterm1.namespace == goterm2.namespace:
dca = deepest_common_ancestor([go_id1, go_id2], godag)
# Then get the distance from the DCA to each term
dca_depth = godag[dca].depth
depth1 = goterm1.depth - dca_depth
depth2 = goterm2.depth - dca_depth
# Return the total distance - i.e., to the deepest common ancestor and back.
return depth1 + depth2
if branch_dist is not None:
return goterm1.depth + goterm2.depth + branch_dist
return None
def semantic_distance(go_id1, go_id2, godag, branch_dist=None):
'''
Finds the semantic distance (minimum number of connecting branches)
between two GO terms.
'''
return min_branch_length(go_id1, go_id2, godag, branch_dist)
def semantic_similarity(go_id1, go_id2, godag, branch_dist=None):
'''
Finds the semantic similarity (inverse of the semantic distance)
between two GO terms.
'''
dist = semantic_distance(go_id1, go_id2, godag, branch_dist)
if dist is not None:
return 1.0 / float(dist) if dist != 0 else 1.0
return None
# 1. Schlicker, Andreas et al.
# "A new measure for functional similarity of gene products based on Gene Ontology"
# BMC Bioinformatics (2006)
#
# 2. Yang, Haixuan et al.
# Improving GO semantic similarity measures by exploring the ontology
# beneath the terms and modelling uncertainty
# Bioinformatics (2012)
|
# Copyright 2014 NetApp
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""The shares api."""
from oslo_db import exception as db_exception
from oslo_log import log
from oslo_utils import timeutils
import six
import webob
from webob import exc
from manila.api import common
from manila.api.openstack import api_version_request as api_version
from manila.api.openstack import wsgi
from manila.api.views import share_networks as share_networks_views
from manila.db import api as db_api
from manila import exception
from manila.i18n import _
from manila import policy
from manila import quota
from manila.share import rpcapi as share_rpcapi
RESOURCE_NAME = 'share_network'
RESOURCES_NAME = 'share_networks'
LOG = log.getLogger(__name__)
QUOTAS = quota.QUOTAS
class ShareNetworkController(wsgi.Controller):
"""The Share Network API controller for the OpenStack API."""
_view_builder_class = share_networks_views.ViewBuilder
def __init__(self):
super(ShareNetworkController, self).__init__()
self.share_rpcapi = share_rpcapi.ShareAPI()
def show(self, req, id):
"""Return data about the requested network info."""
context = req.environ['manila.context']
policy.check_policy(context, RESOURCE_NAME, 'show')
try:
share_network = db_api.share_network_get(context, id)
except exception.ShareNetworkNotFound as e:
raise exc.HTTPNotFound(explanation=six.text_type(e))
return self._view_builder.build_share_network(req, share_network)
def delete(self, req, id):
"""Delete specified share network."""
context = req.environ['manila.context']
policy.check_policy(context, RESOURCE_NAME, 'delete')
try:
share_network = db_api.share_network_get(context, id)
except exception.ShareNetworkNotFound as e:
raise exc.HTTPNotFound(explanation=six.text_type(e))
share_instances = (
db_api.share_instances_get_all_by_share_network(context, id)
)
if share_instances:
msg = _("Can not delete share network %(id)s, it has "
"%(len)s share(s).") % {'id': id,
'len': len(share_instances)}
LOG.error(msg)
raise exc.HTTPConflict(explanation=msg)
# NOTE(ameade): Do not allow deletion of share network used by share
# group
sg_count = db_api.count_share_groups_in_share_network(context, id)
if sg_count:
msg = _("Can not delete share network %(id)s, it has %(len)s "
"share group(s).") % {'id': id, 'len': sg_count}
LOG.error(msg)
raise exc.HTTPConflict(explanation=msg)
for share_server in share_network['share_servers']:
self.share_rpcapi.delete_share_server(context, share_server)
db_api.share_network_delete(context, id)
try:
reservations = QUOTAS.reserve(
context, project_id=share_network['project_id'],
share_networks=-1, user_id=share_network['user_id'])
except Exception:
LOG.exception("Failed to update usages deleting "
"share-network.")
else:
QUOTAS.commit(context, reservations,
project_id=share_network['project_id'],
user_id=share_network['user_id'])
return webob.Response(status_int=202)
def _get_share_networks(self, req, is_detail=True):
"""Returns a list of share networks."""
context = req.environ['manila.context']
search_opts = {}
search_opts.update(req.GET)
if 'security_service_id' in search_opts:
networks = db_api.share_network_get_all_by_security_service(
context, search_opts['security_service_id'])
elif context.is_admin and 'project_id' in search_opts:
networks = db_api.share_network_get_all_by_project(
context, search_opts['project_id'])
elif context.is_admin and 'all_tenants' in search_opts:
networks = db_api.share_network_get_all(context)
else:
networks = db_api.share_network_get_all_by_project(
context,
context.project_id)
date_parsing_error_msg = '''%s is not in yyyy-mm-dd format.'''
if 'created_since' in search_opts:
try:
created_since = timeutils.parse_strtime(
search_opts['created_since'],
fmt="%Y-%m-%d")
except ValueError:
msg = date_parsing_error_msg % search_opts['created_since']
raise exc.HTTPBadRequest(explanation=msg)
networks = [network for network in networks
if network['created_at'] >= created_since]
if 'created_before' in search_opts:
try:
created_before = timeutils.parse_strtime(
search_opts['created_before'],
fmt="%Y-%m-%d")
except ValueError:
msg = date_parsing_error_msg % search_opts['created_before']
raise exc.HTTPBadRequest(explanation=msg)
networks = [network for network in networks
if network['created_at'] <= created_before]
opts_to_remove = [
'all_tenants',
'created_since',
'created_before',
'limit',
'offset',
'security_service_id',
'project_id'
]
for opt in opts_to_remove:
search_opts.pop(opt, None)
if search_opts:
for key, value in search_opts.items():
if key in ['ip_version', 'segmentation_id']:
value = int(value)
if (req.api_version_request >=
api_version.APIVersionRequest("2.36")):
networks = [network for network in networks
if network.get(key) == value or
(value in network.get(key.rstrip('~'))
if key.endswith('~') and
network.get(key.rstrip('~')) else ())]
else:
networks = [network for network in networks
if network.get(key) == value]
limited_list = common.limited(networks, req)
return self._view_builder.build_share_networks(
req, limited_list, is_detail)
def index(self, req):
"""Returns a summary list of share networks."""
policy.check_policy(req.environ['manila.context'], RESOURCE_NAME,
'index')
return self._get_share_networks(req, is_detail=False)
def detail(self, req):
"""Returns a detailed list of share networks."""
policy.check_policy(req.environ['manila.context'], RESOURCE_NAME,
'detail')
return self._get_share_networks(req)
def update(self, req, id, body):
"""Update specified share network."""
context = req.environ['manila.context']
policy.check_policy(context, RESOURCE_NAME, 'update')
if not body or RESOURCE_NAME not in body:
raise exc.HTTPUnprocessableEntity()
try:
share_network = db_api.share_network_get(context, id)
except exception.ShareNetworkNotFound as e:
raise exc.HTTPNotFound(explanation=six.text_type(e))
update_values = body[RESOURCE_NAME]
if 'nova_net_id' in update_values:
msg = _("nova networking is not supported starting in Ocata.")
raise exc.HTTPBadRequest(explanation=msg)
if share_network['share_servers']:
for value in update_values:
if value not in ['name', 'description']:
msg = (_("Cannot update share network %s. It is used by "
"share servers. Only 'name' and 'description' "
"fields are available for update") %
share_network['id'])
raise exc.HTTPForbidden(explanation=msg)
try:
share_network = db_api.share_network_update(context,
id,
update_values)
except db_exception.DBError:
msg = "Could not save supplied data due to database error"
raise exc.HTTPBadRequest(explanation=msg)
return self._view_builder.build_share_network(req, share_network)
def create(self, req, body):
"""Creates a new share network."""
context = req.environ['manila.context']
policy.check_policy(context, RESOURCE_NAME, 'create')
if not body or RESOURCE_NAME not in body:
raise exc.HTTPUnprocessableEntity()
values = body[RESOURCE_NAME]
values['project_id'] = context.project_id
values['user_id'] = context.user_id
if 'nova_net_id' in values:
msg = _("nova networking is not supported starting in Ocata.")
raise exc.HTTPBadRequest(explanation=msg)
try:
reservations = QUOTAS.reserve(context, share_networks=1)
except exception.OverQuota as e:
overs = e.kwargs['overs']
usages = e.kwargs['usages']
quotas = e.kwargs['quotas']
def _consumed(name):
return (usages[name]['reserved'] + usages[name]['in_use'])
if 'share_networks' in overs:
LOG.warning("Quota exceeded for %(s_pid)s, "
"tried to create "
"share-network (%(d_consumed)d of %(d_quota)d "
"already consumed).", {
's_pid': context.project_id,
'd_consumed': _consumed('share_networks'),
'd_quota': quotas['share_networks']})
raise exception.ShareNetworksLimitExceeded(
allowed=quotas['share_networks'])
else:
try:
share_network = db_api.share_network_create(context, values)
except db_exception.DBError:
msg = "Could not save supplied data due to database error"
raise exc.HTTPBadRequest(explanation=msg)
QUOTAS.commit(context, reservations)
return self._view_builder.build_share_network(req, share_network)
def action(self, req, id, body):
_actions = {
'add_security_service': self._add_security_service,
'remove_security_service': self._remove_security_service
}
for action, data in body.items():
try:
return _actions[action](req, id, data)
except KeyError:
msg = _("Share networks does not have %s action") % action
raise exc.HTTPBadRequest(explanation=msg)
def _add_security_service(self, req, id, data):
"""Associate share network with a given security service."""
context = req.environ['manila.context']
policy.check_policy(context, RESOURCE_NAME, 'add_security_service')
share_network = db_api.share_network_get(context, id)
if share_network['share_servers']:
msg = _("Cannot add security services. Share network is used.")
raise exc.HTTPForbidden(explanation=msg)
security_service = db_api.security_service_get(
context, data['security_service_id'])
for attached_service in share_network['security_services']:
if attached_service['type'] == security_service['type']:
msg = _("Cannot add security service to share network. "
"Security service with '%(ss_type)s' type already "
"added to '%(sn_id)s' share network") % {
'ss_type': security_service['type'],
'sn_id': share_network['id']}
raise exc.HTTPConflict(explanation=msg)
try:
share_network = db_api.share_network_add_security_service(
context,
id,
data['security_service_id'])
except KeyError:
msg = "Malformed request body"
raise exc.HTTPBadRequest(explanation=msg)
except exception.NotFound as e:
raise exc.HTTPNotFound(explanation=six.text_type(e))
except exception.ShareNetworkSecurityServiceAssociationError as e:
raise exc.HTTPBadRequest(explanation=six.text_type(e))
return self._view_builder.build_share_network(req, share_network)
def _remove_security_service(self, req, id, data):
"""Dissociate share network from a given security service."""
context = req.environ['manila.context']
policy.check_policy(context, RESOURCE_NAME, 'remove_security_service')
share_network = db_api.share_network_get(context, id)
if share_network['share_servers']:
msg = _("Cannot remove security services. Share network is used.")
raise exc.HTTPForbidden(explanation=msg)
try:
share_network = db_api.share_network_remove_security_service(
context,
id,
data['security_service_id'])
except KeyError:
msg = "Malformed request body"
raise exc.HTTPBadRequest(explanation=msg)
except exception.NotFound as e:
raise exc.HTTPNotFound(explanation=six.text_type(e))
except exception.ShareNetworkSecurityServiceDissociationError as e:
raise exc.HTTPBadRequest(explanation=six.text_type(e))
return self._view_builder.build_share_network(req, share_network)
def create_resource():
return wsgi.Resource(ShareNetworkController())
|
class LazyRef(object):
def __init__(self, fget):
self.fget = fget
self.name = fget.__name__
def __get__(self, instance, cls):
value = self.fget(instance)
instance.__dict__[self.name] = value
return value
class LazyProperty(object):
def __init__(self, fget=None, fset=None, fdel=None, doc=None):
if doc is None and fget is not None and hasattr(fget, '__doc__'):
doc = fget.__doc__
self.fget = fget
self.fset = fset
self.fdel = fdel
self.__doc__ = doc
self.value = None
def __get__(self, instance, cls):
if self.fget is None:
raise AttributeError('unreadable attribute')
if self.value is None:
self.value = self.fget(instance)
return self.value
def __set__(self, instance, value):
if self.fset is None:
raise AttributeError('can\'t set attribute')
self.value = None
return self.fset(instance, value)
def __delete__(self, instance):
if self.fdel is None:
raise AttributeError('can\'t delete attribute')
self.value = None
return self.fdel(instance)
def getter(self, func):
self.fget = func
return self
def setter(self, func):
self.fset = func
return self
def deleter(self, func):
self.fdel = func
return self
|
import numpy as np
import pickle
import cv2
from skimage.feature import hog
from skimage.transform import pyramid_gaussian
print(cv2.__version__)
windowSize = [120,120]
stepSize = 60
def sliding_window(image, stepSize, windowSize):
# slide a window across the image
for x in range(0, image.shape[0], stepSize):
for y in range(0, image.shape[1], stepSize):
yield (x, y, image[ x:x + windowSize[0], y:y + windowSize[0]] )
def slidPyramid(image):
# METHOD #2: Resizing + Gaussian smoothing.
for (i, resized) in enumerate(pyramid_gaussian( image, downscale=2)):
# if the image is too small, break from the loop
if resized.shape[0] < 30 or resized.shape[1] < 30:
break
for x, y, ImagePart in sliding_window(resized,stepSize, windowSize):
yield (x,y, ImagePart)
#### Import Objects
svc = pickle.load(open("saved_svc.p", 'rb'))
outerImg = cv2.imread('test Data/Mijas-Car-Park.jpg')
# -*- coding: utf-8 -*-
video_src = 'test Data/video2.avi'
cap = cv2.VideoCapture(video_src)
while True:
ret, img = cap.read()
if (type(img) == type(None)):
break
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
for x, y, slice in slidPyramid(gray):
hog_feature = hog(slice, orientations=8, pixels_per_cell=(8, 8), cells_per_block=(1, 1), visualise=False, feature_vector=True)
length = 1800
print(len( hog_feature))
hog_feature = np.array([np.hstack(( hog_feature, [0] * (length - len( hog_feature)))) ])
if svc.predict( hog_feature ) is 1 :
# w, h = imageWindow.shape[1] ,imageWindow.shape[0]
# # cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 2)
cv2.imshow('video', slice)
cv2.waitKey(0)
#
# if cv2.waitKey(33) == 27:
# break
#
# cv2.destroyAllWindows()
|
# -*- coding: utf-8 -*-
# Copyright 2017 ProjectQ-Framework (www.projectq.ch)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Module uses ideas from "Basic circuit compilation techniques for an
# ion-trap quantum machine" by Dmitri Maslov (2017) at
# https://iopscience.iop.org/article/10.1088/1367-2630/aa5e47
"""
Registers a decomposition for the H gate into an Ry and Rx gate.
"""
import math
from projectq.cengines import DecompositionRule
from projectq.meta import get_control_count
from projectq.ops import Ph, Rx, Ry, H
def _decompose_h2rx_M(cmd): # pylint: disable=invalid-name
"""Decompose the Ry gate."""
# Labelled 'M' for 'minus' because decomposition ends with a Ry(-pi/2)
qubit = cmd.qubits[0]
Rx(math.pi) | qubit
Ph(math.pi / 2) | qubit
Ry(-1 * math.pi / 2) | qubit
def _decompose_h2rx_N(cmd): # pylint: disable=invalid-name
"""Decompose the Ry gate."""
# Labelled 'N' for 'neutral' because decomposition doesn't end with
# Ry(pi/2) or Ry(-pi/2)
qubit = cmd.qubits[0]
Ry(math.pi / 2) | qubit
Ph(3 * math.pi / 2) | qubit
Rx(-1 * math.pi) | qubit
def _recognize_HNoCtrl(cmd): # pylint: disable=invalid-name
"""For efficiency reasons only if no control qubits."""
return get_control_count(cmd) == 0
#: Decomposition rules
all_defined_decomposition_rules = [
DecompositionRule(H.__class__, _decompose_h2rx_N, _recognize_HNoCtrl),
DecompositionRule(H.__class__, _decompose_h2rx_M, _recognize_HNoCtrl),
]
|
__author__ = 'Dennis'
import csv
class Log(object):
"""
Simple log that contains all experiment information (actions, observations).
Time based. Logs for every time step what happened.
Can (not yet) be read from/to files etc.
"""
def __init__(self):
"""
Attributes
----------
log : [{}]
All entries.
An entry describes time, type of entry and its type-related data.
verbose : bool
If set to True, logging attempts are printed to stdout.
"""
self.log = []
self.verbose = False
self.time = 0
self.length = 0
def read_file(self, file_name):
"""
Parameters
----------
file_name : string
Name of the file to read the log from.
"""
self.__from_file(file_name)
def set_verbose(self, verbose=True):
self.verbose = verbose
def get_length(self):
return self.length
def get_at_time(self, time):
entries = []
for e in self.log:
if e["_time"] == time:
entries.append(e)
return entries
def time_tick(self, time=None):
if time is None:
self.time += 1
else:
self.time = time
if self.verbose:
print "t {0}".format(self.time)
def do_log(self, kind, data):
entry = {"_time": self.time, "_type": kind}
entry.update(data)
self.log.append(entry)
self.length = self.time
if self.verbose:
print entry
def write_file(self, name):
"""
Writes all entries to a file.
Parameters
----------
name : string
Name of the file to write to.
"""
f = open(name, 'wt')
try:
writer = csv.DictWriter(f)
for entry in self.log:
writer.writerow(entry)
finally:
f.close()
def __from_file(self, name):
"""
Reads all entries from a file.
Parameters
----------
name : string
Name of the file to read from.
"""
f = open(name, 'rt')
try:
reader = csv.DictReader(f)
for row in reader:
self.log.append(row)
finally:
f.close()
def make_data(self, file_name, attribute_labels, number=None):
"""
Parameters
----------
file : string
File name to write to.
"""
suffix = "" if number is None else "_{0}".format(str(number))
f = open(file_name + suffix + ".csv", "wt")
try:
writer = csv.writer(f, delimiter=' ')
# Calculate changes in position for every limb.
attributes = attribute_labels.keys()
labels = attribute_labels.values()
data = []
for entry in self.log:
if "observation" in entry and entry["observation"] in attributes:
t = entry["_time"]
if len(data) - 1 < t:
data.append({})
data[t][entry["observation"]] = entry["value"]
writer.writerow(["t"] + labels)
for i in range(len(data) - 1):
k = [0] * len(attributes)
for p in range(len(attributes)):
if data[i][attributes[p]] != data[i + 1][attributes[p]]:
k[p] = 1
writer.writerow([i] + k)
finally:
f.close()
@staticmethod
def make_bins(name, c, n, number=None):
"""
Parameters
----------
c : int
Number of columns next to the time column.
"""
suffix = "" if number is None else "_{0}".format(str(number))
f = open(name + suffix + ".csv", "rt")
o = open(name + suffix + "_bins.csv", "wt")
try:
# Skip header
f.readline()
reader = csv.reader(f, delimiter=' ')
bins = []
i_bin = 1
current = [0] * len(c)
for row in reader:
if int(row[0]) >= i_bin * n:
bins.append(current)
i_bin += 1
current = [0] * len(c)
current = [x + y for (x, y) in zip(current, [int(z) for z in row[1:]])]
bins.append(current)
writer = csv.writer(o, delimiter=' ')
writer.writerow(["block"] + c)
for i in range(len(bins)):
writer.writerow([str(i)] + [str(x) for x in bins[i]])
finally:
f.close()
o.close()
@staticmethod
def write_data(name, c, data):
o = open(name + ".csv", "wt")
try:
writer = csv.writer(o, delimiter=' ')
writer.writerow(["block"] + c)
for i in range(len(data)):
writer.writerow([str(i)] + [str(x) for x in data[i]])
finally:
o.close()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.